In this notebook, we'll look into modelling implied trading within an exchange. Implied trading refers to ability to connect liquidity on strategy and outright order books (e.g. Euronext).

1 Type definitions and printers

1.1 Model type definitions

Our first goal is to setup the various type definitions that we'll use later on.

Try this!
In [1]:
type side = BUY | SELL

type outright_id = OUT1 | OUT2 | OUT3
type strategy_id = STRAT1 | STRAT2
type month = Mar | Jun | Sep | Dec

(* Map an outright with an expiry *)
let contract_expiry = function
  | OUT1 -> Mar
  | OUT2 -> Jun
  | OUT3 -> Sep

(* Convert month to an integer *)
let month_to_int = function
  | Mar -> 3
  | Jun -> 6
  | Sep -> 9
  | Dec -> 12
;;

(* Return true of m1 is nearer (or equal) to m2 *)
let month_comp (m1 : month) (m2 : month) =
  (month_to_int m1) < (month_to_int  m2)
;;

type instrument =
  | Strategy of strategy_id
  | Outright of outright_id

(* Level information *)
type level_info = {
  li_qty : int
  ; li_price : int
}

(* best bid and ask information *)
type best_bid_ask = {
  bid_info : level_info option
  ; ask_info : level_info option
}

(* Best bid/ask for all of the books *)
type books_info = {
  book1 : best_bid_ask
  ; book2 : best_bid_ask
  ; book3 : best_bid_ask
}

(* Order type *)
type order = {
  o_qty : int
  ; o_price : int
  ; o_time : int
  ; o_id : int
  ; o_side : side
  ; o_client_id : int
  ; o_inst : instrument
  ; o_is_implied : bool
}

(* Helper function to make order creation simpler *)
let make si qty price id inst clientid isimp time =
  {o_qty = qty ; o_price = price; o_id = id; o_side = si;
   o_client_id = clientid; o_inst = inst; o_is_implied = isimp;
   o_time = time }


(* outright order book *)
type book = {
  b_buys : order list
  ; b_sells : order list
}

let empty_book = { b_buys = []; b_sells = [] }

(* Individual leg *)
type leg = {
  leg_sec_idx : outright_id
  ; leg_mult : int
}

(* Strategy is composed of legs *)
type strategy = {
  time_created : int
  ; leg1 : leg
  ; leg2 : leg
  ; leg3 : leg
}

(* Helper function to make strategy creation smaller *)
let make_strat tcreated m1 m2 m3 = {
  time_created = tcreated
  ; leg1 = { leg_sec_idx = OUT1; leg_mult = m1 }
  ; leg2 = { leg_sec_idx = OUT2; leg_mult = m2 }
  ; leg3 = { leg_sec_idx = OUT3; leg_mult = m3 }
}

type implied_strat_ord = {
  max_strat : int option
  ; strat_price : int option
}

(* New order message *)
type new_ord_msg = {
  no_client_id : int
  ; no_inst_type : instrument
  ; no_qty : int
  ; no_side : side
  ; no_price : int
}

(* cancel order ID *)
type cancel_ord_msg = {
  co_client_id : int
  ; co_order_id : int
  ; co_instrument : instrument
  ; co_side : side
}

(* Inbound messages type *)
type inbound_msg =
  | NewOrder of new_ord_msg
  | CancelOrder of cancel_ord_msg
  | ImpliedUncross

(* Helper function for creating new order messages *)
let make_no_msg cid inst qty sd p =
 NewOrder {
  no_client_id = cid
  ; no_inst_type = inst
  ; no_qty = qty
  ; no_side = sd
  ; no_price = p
 }

(* ack message *)
type ack_msg = {
  ack_client_id : int
  ; ack_order_id : int
  ; ack_inst_type : instrument
  ; ack_qty : int
  ; ack_side : side
  ; ack_price : int
}

(* fill information *)
type fill = {
  fill_client_id : int
  ; fill_qty : int
  ; fill_price : int
  ; fill_order_id : int
  ; fill_order_done : bool
}

(* uncross result *)
type uncross_res = {
  uncrossed_book : book
  ; uncrossed_fills : fill list
  ; uncrossed_qty : int
}

(* outbound message type *)
type outbound_msg =
  | Ack of ack_msg
  | Fill of fill
  | UncrossResult of uncross_res
;;

(* The entire market - strategy definitions, order books, messages, etc. s*)
type market = {

  (* current time*)
  curr_time : int

  (* used for order ID counter *)
  ; last_ord_id : int

  (* two strategy definitions *)
  ; strat1    : strategy
  ; strat2    : strategy

  (* outright books *)
  ; out_book1 : book
  ; out_book2 : book
  ; out_book3 : book

  (* strategy books *)
  ; s_book1   : book
  ; s_book2   : book

  (* inbound and outbound message queues *)
  ; inbound_msgs  : inbound_msg list
  ; outbound_msgs : outbound_msg list

}
Out[1]:
type side = BUY | SELL
type outright_id = OUT1 | OUT2 | OUT3
type strategy_id = STRAT1 | STRAT2
type month = Mar | Jun | Sep | Dec
val contract_expiry : outright_id -> month = <fun>
val month_to_int : month -> Z.t = <fun>
val month_comp : month -> month -> bool = <fun>
type instrument = Strategy of strategy_id | Outright of outright_id
type level_info = { li_qty : Z.t; li_price : Z.t; }
type best_bid_ask = {
  bid_info : level_info option;
  ask_info : level_info option;
}
type books_info = {
  book1 : best_bid_ask;
  book2 : best_bid_ask;
  book3 : best_bid_ask;
}
type order = {
  o_qty : Z.t;
  o_price : Z.t;
  o_time : Z.t;
  o_id : Z.t;
  o_side : side;
  o_client_id : Z.t;
  o_inst : instrument;
  o_is_implied : bool;
}
val make :
  side -> Z.t -> Z.t -> Z.t -> instrument -> Z.t -> bool -> Z.t -> order =
  <fun>
type book = { b_buys : order list; b_sells : order list; }
val empty_book : book = {b_buys = []; b_sells = []}
type leg = { leg_sec_idx : outright_id; leg_mult : Z.t; }
type strategy = { time_created : Z.t; leg1 : leg; leg2 : leg; leg3 : leg; }
val make_strat : Z.t -> Z.t -> Z.t -> Z.t -> strategy = <fun>
type implied_strat_ord = {
  max_strat : Z.t option;
  strat_price : Z.t option;
}
type new_ord_msg = {
  no_client_id : Z.t;
  no_inst_type : instrument;
  no_qty : Z.t;
  no_side : side;
  no_price : Z.t;
}
type cancel_ord_msg = {
  co_client_id : Z.t;
  co_order_id : Z.t;
  co_instrument : instrument;
  co_side : side;
}
type inbound_msg =
    NewOrder of new_ord_msg
  | CancelOrder of cancel_ord_msg
  | ImpliedUncross
val make_no_msg : Z.t -> instrument -> Z.t -> side -> Z.t -> inbound_msg =
  <fun>
type ack_msg = {
  ack_client_id : Z.t;
  ack_order_id : Z.t;
  ack_inst_type : instrument;
  ack_qty : Z.t;
  ack_side : side;
  ack_price : Z.t;
}
type fill = {
  fill_client_id : Z.t;
  fill_qty : Z.t;
  fill_price : Z.t;
  fill_order_id : Z.t;
  fill_order_done : bool;
}
type uncross_res = {
  uncrossed_book : book;
  uncrossed_fills : fill list;
  uncrossed_qty : Z.t;
}
type outbound_msg =
    Ack of ack_msg
  | Fill of fill
  | UncrossResult of uncross_res
type market = {
  curr_time : Z.t;
  last_ord_id : Z.t;
  strat1 : strategy;
  strat2 : strategy;
  out_book1 : book;
  out_book2 : book;
  out_book3 : book;
  s_book1 : book;
  s_book2 : book;
  inbound_msgs : inbound_msg list;
  outbound_msgs : outbound_msg list;
}

1.2 Custom type printers

One of Imandra's powerful features is the ability to combine logic (pure subset of OCaml) and program (all of OCaml) modes. In the following cell, we will create and install a custom type printer (HTML) for an order book. So that next time a value of this type is computed within a cell, this printer would be used instead of the generic one.

Try this!
In [2]:
(* Here's an example of a custom printer that we can install for arbitrary data types. *)

#program;;
#require "tyxml";;
let html_of_order (o : order) =
  let module H = Tyxml.Html in
  H.div
  ~a:(if o.o_is_implied then [H.a_style "color: red"] else [])
  [ H.div
    ~a:[H.a_style "font-size: 1.4em"]
    [H.txt (Format.asprintf "%s (%s)" (Z.to_string o.o_price) (Z.to_string o.o_qty))]
  ; H.div (if o.o_is_implied then [H.txt "Implied"] else [])
  ]

let doc_of_order (o:order) =
  let module H = Tyxml.Html in
  Document.html (H.div [html_of_order o]);;

#install_doc doc_of_order

let html_of_book ?(title="") (b: book) =
  let module H = Tyxml.Html in
  let rec build_rows acc buys sells =
      match buys, sells with
      | b :: bs, s :: ss -> build_rows (acc @ [H.tr [H.td [html_of_order b]; H.td [html_of_order s]]]) bs ss
      | b :: bs, [] -> build_rows (acc @ [H.tr [H.td [html_of_order b]; H.td [H.txt "-"]]]) bs []
      | [], s :: ss -> build_rows (acc @ [H.tr [H.td [H.txt "-"]; H.td [html_of_order s]]]) [] ss
      | [], [] -> acc
  in
  H.div
  ~a:[H.a_style "margin-right:1em; display: flex; flex-direction: column; align-items: center; justify-content: flex-start"]
  [ H.div ~a:[H.a_style "font-weight: bold"] [H.txt title]
  ; H.table
    ~thead:(H.thead [H.tr [H.th [H.txt "Buys"]; H.th [H.txt "Sells"]]])
    (build_rows [] b.b_buys b.b_sells)]

let doc_of_book (b:book) =
  let module H = Tyxml.Html in
  Document.html (H.div [html_of_book ~title:"M1 Mar21" b]);;

#install_doc doc_of_book;;

let html_of_market (m: market) =
  let module H = Tyxml.Html in
  H.div
  [ H.div ~a:[H.a_style "display: flex"]
    [ html_of_book ~title:"Strategy 1" m.s_book1
    ; html_of_book ~title:"Strategy 2" m.s_book2
    ]
  ; H.div ~a:[H.a_style "margin-top: 1em; display: flex"]
    [ html_of_book ~title:"Book 1" m.out_book1
    ; html_of_book ~title:"Book 2" m.out_book2
    ; html_of_book ~title:"Book 3" m.out_book3
    ]]

let doc_of_market (m : market) =
  let module H = Tyxml.Html in
  Document.html (html_of_market m);;

#install_doc doc_of_market;;

#logic;;
Out[2]:
/usr/local/var/imandra/_opam/lib/re: added to search path
/usr/local/var/imandra/_opam/lib/re/re.cma: loaded
/usr/local/var/imandra/_opam/lib/uchar: added to search path
/usr/local/var/imandra/_opam/lib/uutf: added to search path
/usr/local/var/imandra/_opam/lib/uutf/uutf.cma: loaded
/usr/local/var/imandra/_opam/lib/tyxml/functor: added to search path
/usr/local/var/imandra/_opam/lib/tyxml/functor/tyxml_f.cma: loaded
/usr/local/var/imandra/_opam/lib/tyxml: added to search path
/usr/local/var/imandra/_opam/lib/tyxml/tyxml.cma: loaded
- : unit = ()
val html_of_order : order -> [> Html_types.div ] Tyxml_html.elt = <fun>
File "jupyter cell 2", line 17, characters 16-41:
Error: This expression has type [> Html_types.div ] H.elt
       but an expression was expected of type Document.html
Line 2, characters 18-30:
2 |           let d = doc_of_order x in
                      ^^^^^^^^^^^^
Error: Unbound value doc_of_order
val html_of_book :
  ?title:string -> book -> [> Html_types.div ] Tyxml_html.elt = <fun>
File "jupyter cell 2", line 39, characters 16-58:
Error: This expression has type [> Html_types.div ] H.elt
       but an expression was expected of type Document.html
Line 2, characters 18-29:
2 |           let d = doc_of_book x in
                      ^^^^^^^^^^^
Error: Unbound value doc_of_book
val html_of_market : market -> [> Html_types.div ] Tyxml_html.elt = <fun>
File "jupyter cell 2", line 58, characters 16-34:
Error: This expression has type [> Html_types.div ] H.elt
       but an expression was expected of type Document.html
Line 2, characters 18-31:
2 |           let d = doc_of_market x in
                      ^^^^^^^^^^^^^
Error: Unbound value doc_of_market

1.3 Custom type printer example

Try this!
In [3]:
let leg = { leg_sec_idx = OUT1; leg_mult = 1 } in

let strat = { time_created = 0; leg1 = leg; leg2 = leg; leg3 = leg } in

let b1 = {
  b_buys = [
    (make BUY 100 54 1 (Outright OUT1) 1 true 1)
    ;(make BUY 100 54 2 (Outright OUT1) 1 false 1)
  ]
  ; b_sells = [
    (make SELL 100 54 3 (Outright OUT1) 1 false 1)
    ;(make SELL 100 54 4 (Outright OUT1) 1 false 1)
  ] } in

  { curr_time = 1
  ; last_ord_id = 1
  ; strat1 = strat
  ; strat2 = strat
  ; out_book1 = b1
  ; out_book2 = b1
  ; out_book3 = b1
  ; s_book1 = b1
  ; s_book2 = b1
  ; inbound_msgs = []
  ; outbound_msgs = []
  }
Out[3]:
- : market =
{curr_time = 1; last_ord_id = 1;
 strat1 =
  {time_created = 0; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg3 = {leg_sec_idx = OUT1; leg_mult = 1}};
 strat2 =
  {time_created = 0; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg3 = {leg_sec_idx = OUT1; leg_mult = 1}};
 out_book1 =
  {b_buys =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 1; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = true};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 3; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 out_book2 =
  {b_buys =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 1; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = true};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 3; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 out_book3 =
  {b_buys =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 1; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = true};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 3; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 s_book1 =
  {b_buys =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 1; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = true};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 3; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 s_book2 =
  {b_buys =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 1; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = true};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 3; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false};
     {o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = SELL;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 inbound_msgs = []; outbound_msgs = []}

2. Outright uncrossing logic

2.1 Order book operatons (inserting, cancelling orders)

Try this!
In [4]:
(* Convert fills into outbound messages *)
let rec create_fill_msgs (f : fill list) =
  match f with
  | [] -> []
  | x::xs -> (Fill x) :: create_fill_msgs xs

(* TODO: recode this with higher-order functions *)
let rec cancel_ord_side (orders : order list) (c : cancel_ord_msg) =
  match orders with
  | [] -> []
  | x::xs ->
    begin
      if (x.o_client_id = c.co_client_id) && (x.o_id = c.co_order_id) then xs
      else x :: (cancel_ord_side xs c)
    end

(* Helper to cancel orders *)
let cancel_ord_book (co : cancel_ord_msg) (b : book) =
  match co.co_side with
  | BUY -> { b with b_buys = (cancel_ord_side b.b_buys co) }
  | SELL -> { b with b_sells = (cancel_ord_side b.b_sells co) }

(* function used insert individual orders *)
let rec insert_order_side (orders : order list) (o : order) =
  match orders with
  | [] -> [ o ]
  | x::xs ->
    begin
      if o.o_side = BUY then
        (if o.o_price > x.o_price then o :: orders else x :: (insert_order_side xs o))
      else
        (if o.o_price < x.o_price then o :: orders else x :: (insert_order_side xs o))
    end

(* insert order into the book *)
let insert_order (o : order) (b : book) =
  if o.o_side = BUY then
    { b with b_buys = (insert_order_side b.b_buys o) }
  else
    { b with b_sells = (insert_order_side b.b_sells o) }

(* The fills are adjusted to a single fill price during the uncross *)
let rec adjust_fill_prices (fills : fill list) ( f_price : int ) =
  match fills with
  | [] -> []
  | x::xs -> { x with fill_price = f_price } :: ( adjust_fill_prices xs f_price )
;;
Out[4]:
val create_fill_msgs : fill list -> outbound_msg list = <fun>
val cancel_ord_side : order list -> cancel_ord_msg -> order list = <fun>
val cancel_ord_book : cancel_ord_msg -> book -> book = <fun>
val insert_order_side : order list -> order -> order list = <fun>
val insert_order : order -> book -> book = <fun>
val adjust_fill_prices : fill list -> Z.t -> fill list = <fun>
termination proof

Termination proof

call `create_fill_msgs (List.tl f)` from `create_fill_msgs f`
{original: create_fill_msgs f ---------------------------------------------------------------------------- sub: create_fill_msgs (List.tl f) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt f) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl f)) ---------------------------------------------------------------------------- path: [not Is_a([], f)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.168s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 12 ---------------------------------------------------------------------------- arith-make-feasible: 77 ---------------------------------------------------------------------------- arith-max-columns: 51 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 4061 ---------------------------------------------------------------------------- mk clause: 114 ---------------------------------------------------------------------------- datatype occurs check: 45 ---------------------------------------------------------------------------- mk bool var: 175 ---------------------------------------------------------------------------- arith-lower: 44 ---------------------------------------------------------------------------- datatype splits: 3 ---------------------------------------------------------------------------- decisions: 65 ---------------------------------------------------------------------------- propagations: 73 ---------------------------------------------------------------------------- interface eqs: 12 ---------------------------------------------------------------------------- arith-max-rows: 25 ---------------------------------------------------------------------------- conflicts: 8 ---------------------------------------------------------------------------- datatype accessor ax: 9 ---------------------------------------------------------------------------- datatype constructor ax: 7 ---------------------------------------------------------------------------- num allocs: 706581 ---------------------------------------------------------------------------- final checks: 18 ---------------------------------------------------------------------------- added eqs: 131 ---------------------------------------------------------------------------- del clause: 87 ---------------------------------------------------------------------------- arith eq adapter: 42 ---------------------------------------------------------------------------- arith-upper: 68 ---------------------------------------------------------------------------- memory: 5.250000 ---------------------------------------------------------------------------- max memory: 5.250000 } } }) (full: * ```start[0.168s] let (_x_0 : int) = count.list count.fill f in let (_x_1 : fill list) = List.tl f in let (_x_2 : int) = count.list count.fill _x_1 in not Is_a([], f) && _x_0 >= 0 && _x_2 >= 0 ==> Is_a([], _x_1) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : fill list) = List.tl f in let (_x_1 : int) = count.list count.fill _x_0 in let (_x_2 : int) = count.list count.fill f in (Is_a([], _x_0) || Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2)) || not ((not Is_a([], f) && _x_2 >= 0) && _x_1 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `cancel_ord_side (List.tl orders) c` from `cancel_ord_side orders c`
{original: cancel_ord_side orders c ---------------------------------------------------------------------------- sub: cancel_ord_side (List.tl orders) c ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [let (_x_0 : order) = List.hd orders in not (_x_0.o_client_id = c.co_client_id && _x_0.o_id = c.co_order_id) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.039s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 15 ---------------------------------------------------------------------------- arith-make-feasible: 82 ---------------------------------------------------------------------------- arith-max-columns: 60 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 9591 ---------------------------------------------------------------------------- mk clause: 130 ---------------------------------------------------------------------------- datatype occurs check: 71 ---------------------------------------------------------------------------- mk bool var: 339 ---------------------------------------------------------------------------- arith-lower: 44 ---------------------------------------------------------------------------- datatype splits: 51 ---------------------------------------------------------------------------- decisions: 102 ---------------------------------------------------------------------------- propagations: 75 ---------------------------------------------------------------------------- interface eqs: 15 ---------------------------------------------------------------------------- arith-max-rows: 29 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 34 ---------------------------------------------------------------------------- datatype constructor ax: 80 ---------------------------------------------------------------------------- num allocs: 2038821 ---------------------------------------------------------------------------- final checks: 21 ---------------------------------------------------------------------------- added eqs: 400 ---------------------------------------------------------------------------- del clause: 97 ---------------------------------------------------------------------------- arith eq adapter: 43 ---------------------------------------------------------------------------- arith-upper: 71 ---------------------------------------------------------------------------- memory: 8.180000 ---------------------------------------------------------------------------- max memory: 8.180000 } } }) (full: * ```start[0.039s] let (_x_0 : order) = List.hd orders in let (_x_1 : int) = c.co_client_id in let (_x_2 : int) = c.co_order_id in let (_x_3 : int) = count.list count.order orders in let (_x_4 : order list) = List.tl orders in let (_x_5 : int) = count.list count.order _x_4 in let (_x_6 : order) = List.hd _x_4 in not (_x_0.o_client_id = _x_1 && _x_0.o_id = _x_2) && not Is_a([], orders) && _x_3 >= 0 && _x_5 >= 0 ==> not (not (_x_6.o_client_id = _x_1 && _x_6.o_id = _x_2) && not Is_a([], _x_4)) || Ordinal.( << ) (Ordinal.Int _x_5) (Ordinal.Int _x_3)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl orders in let (_x_1 : int) = count.list count.order _x_0 in let (_x_2 : int) = count.list count.order orders in let (_x_3 : order) = List.hd _x_0 in let (_x_4 : int) = c.co_client_id in let (_x_5 : int) = c.co_order_id in let (_x_6 : order) = List.hd orders in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not (not (_x_3.o_client_id = _x_4 && _x_3.o_id = _x_5) && not Is_a([], _x_0))) || not (((not (_x_6.o_client_id = _x_4 && _x_6.o_id = _x_5) && not Is_a([], orders)) && _x_2 >= 0) && _x_1 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `insert_order_side (List.tl orders) o` from `insert_order_side orders o`
{original: insert_order_side orders o ---------------------------------------------------------------------------- sub: insert_order_side (List.tl orders) o ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [not (o.o_price > (List.hd orders).o_price) && o.o_side = BUY && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.030s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 13 ---------------------------------------------------------------------------- arith-make-feasible: 76 ---------------------------------------------------------------------------- arith-max-columns: 62 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 19996 ---------------------------------------------------------------------------- mk clause: 123 ---------------------------------------------------------------------------- datatype occurs check: 120 ---------------------------------------------------------------------------- mk bool var: 340 ---------------------------------------------------------------------------- arith-lower: 41 ---------------------------------------------------------------------------- datatype splits: 55 ---------------------------------------------------------------------------- decisions: 93 ---------------------------------------------------------------------------- propagations: 76 ---------------------------------------------------------------------------- interface eqs: 13 ---------------------------------------------------------------------------- arith-max-rows: 30 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 34 ---------------------------------------------------------------------------- datatype constructor ax: 78 ---------------------------------------------------------------------------- num allocs: 10943303 ---------------------------------------------------------------------------- final checks: 19 ---------------------------------------------------------------------------- added eqs: 415 ---------------------------------------------------------------------------- del clause: 90 ---------------------------------------------------------------------------- arith eq adapter: 40 ---------------------------------------------------------------------------- arith-upper: 69 ---------------------------------------------------------------------------- memory: 8.240000 ---------------------------------------------------------------------------- max memory: 10.910000 } } }) (full: * ```start[0.030s] let (_x_0 : int) = o.o_price in let (_x_1 : bool) = o.o_side = BUY in let (_x_2 : int) = count.list count.order orders in let (_x_3 : order list) = List.tl orders in let (_x_4 : int) = count.list count.order _x_3 in let (_x_5 : int) = (List.hd _x_3).o_price in let (_x_6 : bool) = not Is_a([], _x_3) in not (_x_0 > (List.hd orders).o_price) && _x_1 && not Is_a([], orders) && _x_2 >= 0 && _x_4 >= 0 ==> not (not (_x_0 > _x_5) && _x_1 && _x_6) && not (not (_x_0 < _x_5) && not _x_1 && _x_6) || Ordinal.( << ) (Ordinal.Int _x_4) (Ordinal.Int _x_2)``` * simplify:: {into: ```let (_x_0 : int) = o.o_price in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = (List.hd _x_1).o_price in let (_x_3 : bool) = o.o_side = BUY in let (_x_4 : bool) = not Is_a([], _x_1) in let (_x_5 : int) = count.list count.order _x_1 in let (_x_6 : int) = count.list count.order orders in (not ((_x_0 <= _x_2 && _x_3) && _x_4) && not ((_x_2 <= _x_0 && not _x_3) && _x_4) || Ordinal.( << ) (Ordinal.Int _x_5) (Ordinal.Int _x_6)) || not ((((_x_0 <= (List.hd orders).o_price && _x_3) && not Is_a([], orders)) && _x_6 >= 0) && _x_5 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
call `insert_order_side (List.tl orders) o` from `insert_order_side orders o`
{original: insert_order_side orders o ---------------------------------------------------------------------------- sub: insert_order_side (List.tl orders) o ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [not (o.o_price < (List.hd orders).o_price) && not (o.o_side = BUY) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.025s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 5 ---------------------------------------------------------------------------- arith-make-feasible: 32 ---------------------------------------------------------------------------- arith-max-columns: 42 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 14479 ---------------------------------------------------------------------------- mk clause: 73 ---------------------------------------------------------------------------- datatype occurs check: 57 ---------------------------------------------------------------------------- mk bool var: 344 ---------------------------------------------------------------------------- arith-lower: 18 ---------------------------------------------------------------------------- datatype splits: 79 ---------------------------------------------------------------------------- decisions: 70 ---------------------------------------------------------------------------- propagations: 43 ---------------------------------------------------------------------------- interface eqs: 5 ---------------------------------------------------------------------------- arith-max-rows: 17 ---------------------------------------------------------------------------- conflicts: 8 ---------------------------------------------------------------------------- datatype accessor ax: 47 ---------------------------------------------------------------------------- datatype constructor ax: 100 ---------------------------------------------------------------------------- num allocs: 5576142 ---------------------------------------------------------------------------- final checks: 11 ---------------------------------------------------------------------------- added eqs: 454 ---------------------------------------------------------------------------- del clause: 40 ---------------------------------------------------------------------------- arith eq adapter: 16 ---------------------------------------------------------------------------- arith-upper: 27 ---------------------------------------------------------------------------- memory: 8.180000 ---------------------------------------------------------------------------- max memory: 8.180000 } } }) (full: * ```start[0.025s] let (_x_0 : int) = o.o_price in let (_x_1 : bool) = o.o_side = BUY in let (_x_2 : bool) = not _x_1 in let (_x_3 : int) = count.list count.order orders in let (_x_4 : order list) = List.tl orders in let (_x_5 : int) = count.list count.order _x_4 in let (_x_6 : int) = (List.hd _x_4).o_price in let (_x_7 : bool) = not Is_a([], _x_4) in not (_x_0 < (List.hd orders).o_price) && _x_2 && not Is_a([], orders) && _x_3 >= 0 && _x_5 >= 0 ==> not (not (_x_0 > _x_6) && _x_1 && _x_7) && not (not (_x_0 < _x_6) && _x_2 && _x_7) || Ordinal.( << ) (Ordinal.Int _x_5) (Ordinal.Int _x_3)``` * simplify:: {into: ```let (_x_0 : int) = o.o_price in let (_x_1 : bool) = o.o_side = BUY in let (_x_2 : bool) = not _x_1 in let (_x_3 : int) = count.list count.order orders in let (_x_4 : order list) = List.tl orders in let (_x_5 : int) = count.list count.order _x_4 in let (_x_6 : int) = (List.hd _x_4).o_price in let (_x_7 : bool) = not Is_a([], _x_4) in (not (((((List.hd orders).o_price <= _x_0 && _x_2) && not Is_a([], orders)) && _x_3 >= 0) && _x_5 >= 0) || not ((_x_0 <= _x_6 && _x_1) && _x_7) && not ((_x_6 <= _x_0 && _x_2) && _x_7)) || Ordinal.( << ) (Ordinal.Int _x_5) (Ordinal.Int _x_3)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `adjust_fill_prices (List.tl fills) f_price` from `adjust_fill_prices fills f_price`
{original: adjust_fill_prices fills f_price ---------------------------------------------------------------------------- sub: adjust_fill_prices (List.tl fills) f_price ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt fills) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl fills)) ---------------------------------------------------------------------------- path: [not Is_a([], fills)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.025s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 11 ---------------------------------------------------------------------------- arith-make-feasible: 68 ---------------------------------------------------------------------------- arith-max-columns: 51 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 23796 ---------------------------------------------------------------------------- mk clause: 104 ---------------------------------------------------------------------------- datatype occurs check: 42 ---------------------------------------------------------------------------- mk bool var: 160 ---------------------------------------------------------------------------- arith-lower: 37 ---------------------------------------------------------------------------- datatype splits: 3 ---------------------------------------------------------------------------- decisions: 54 ---------------------------------------------------------------------------- propagations: 63 ---------------------------------------------------------------------------- interface eqs: 11 ---------------------------------------------------------------------------- arith-max-rows: 24 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 9 ---------------------------------------------------------------------------- datatype constructor ax: 7 ---------------------------------------------------------------------------- num allocs: 14232632 ---------------------------------------------------------------------------- final checks: 17 ---------------------------------------------------------------------------- added eqs: 114 ---------------------------------------------------------------------------- del clause: 77 ---------------------------------------------------------------------------- arith eq adapter: 35 ---------------------------------------------------------------------------- arith-upper: 58 ---------------------------------------------------------------------------- memory: 10.970000 ---------------------------------------------------------------------------- max memory: 10.970000 } } }) (full: * ```start[0.025s] let (_x_0 : int) = count.list count.fill fills in let (_x_1 : fill list) = List.tl fills in let (_x_2 : int) = count.list count.fill _x_1 in not Is_a([], fills) && _x_0 >= 0 && _x_2 >= 0 ==> Is_a([], _x_1) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : fill list) = List.tl fills in let (_x_1 : int) = count.list count.fill _x_0 in let (_x_2 : int) = count.list count.fill fills in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not ((not Is_a([], fills) && _x_2 >= 0) && _x_1 >= 0)) || Is_a([], _x_0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }

2.2 Book uncross

Try this!
In [5]:
(* Measure for proving termination of `uncross_book` below *)
let book_measure b =
  Ordinal.of_int (List.length b.b_buys + List.length b.b_sells)

let rec uncross_book (b : book) (fills : fill list) (filled_qty : int) =
  match b.b_buys, b.b_sells with
  | [], [] | _, [] | [], _ ->
    (* we need to check whether there have been fills before,
      if so we need to adjust fill prices before getting out *)
    begin
      match fills with
      | [] -> { uncrossed_book = b; uncrossed_fills = fills; uncrossed_qty = filled_qty }
      | x::xs ->
        let fills' = x :: (adjust_fill_prices xs x.fill_price) in
      { uncrossed_book = b; uncrossed_fills = fills'; uncrossed_qty = filled_qty }
    end
  | buy::bs, sell::ss ->
    if buy.o_price >= sell.o_price then
      begin
        (* compute the fill qty and price *)
        let fill_qty = if buy.o_qty < sell.o_qty then buy.o_qty else sell.o_qty in
        let fill_price = (buy.o_price + sell.o_price) / 2 in

        (* update the orders that traded *)
        let buy' = { buy with o_qty = buy.o_qty - fill_qty } in
        let sell' = { sell with o_qty = sell.o_qty - fill_qty } in

        (* create the fills *)
        let fill1 = {
          fill_client_id = buy.o_client_id
          ; fill_qty = fill_qty
          ; fill_price = fill_price
          ; fill_order_id = buy.o_id
          ; fill_order_done = true } in

        let fill2 = {
          fill_client_id = sell.o_client_id
          ; fill_qty = fill_qty
          ; fill_price = fill_price
          ; fill_order_id = sell.o_id
          ; fill_order_done = true } in

        (* now update the books and fills *)
        let new_buys = if buy'.o_qty = 0 then bs else buy'::bs in
        let new_sells = if sell'.o_qty = 0 then ss else sell'::ss in
        let b' = {
          b_buys = new_buys
          ; b_sells = new_sells } in

        (* We should not be generating fills for implied orders - there's
          a different mechanism for that *)
        let fills' = if not buy.o_is_implied then
          fill1 :: fills else fills in
        let fills' = if not sell.o_is_implied then
          fill2 :: fills' else fills' in

        (* recursively go to the next level *)
        uncross_book b' fills' (filled_qty + fill_qty)
      end

    else
      (* nothing to do here *)
      { uncrossed_book = b; uncrossed_fills = fills; uncrossed_qty = filled_qty }
[@@measure book_measure b]
;;
Out[5]:
val book_measure : book -> Ordinal.t = <fun>
val uncross_book : book -> fill list -> Z.t -> uncross_res = <fun>
termination proof

Termination proof

call `let (_x_0 : order list) = b.b_buys in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_qty in let (_x_3 : order list) = b.b_sells in let (_x_4 : order) = List.hd _x_3 in let (_x_5 : int) = _x_4.o_qty in let (_x_6 : int) = if _x_2 < _x_5 then _x_2 else _x_5 in let (_x_7 : int) = _x_2 - _x_6 in let (_x_8 : order list) = List.tl _x_0 in let (_x_9 : int) = _x_5 - _x_6 in let (_x_10 : order list) = List.tl _x_3 in let (_x_11 : int) = (_x_1.o_price + _x_4.o_price) / 2 in let (_x_12 : fill list) = if not _x_1.o_is_implied then {fill_client_id = _x_1.o_client_id; fill_qty = _x_6; fill_price = _x_11; fill_order_id = _x_1.o_id; fill_order_done = true} :: fills else fills in uncross_book {b_buys = if _x_7 = 0 then _x_8 else {_x_1 with o_qty = _x_7} :: _x_8; b_sells = if _x_9 = 0 then _x_10 else {_x_4 with o_qty = _x_9} :: _x_10} (if not _x_4.o_is_implied then {fill_client_id = _x_4.o_client_id; fill_qty = _x_6; fill_price = _x_11; fill_order_id = _x_4.o_id; fill_order_done = true} :: _x_12 else _x_12) (filled_qty + _x_6)` from `uncross_book b fills filled_qty`
{original: uncross_book b fills filled_qty ---------------------------------------------------------------------------- sub: let (_x_0 : order list) = b.b_buys in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_qty in let (_x_3 : order list) = b.b_sells in let (_x_4 : order) = List.hd _x_3 in let (_x_5 : int) = _x_4.o_qty in let (_x_6 : int) = if _x_2 < _x_5 then _x_2 else _x_5 in let (_x_7 : int) = _x_2 - _x_6 in let (_x_8 : order list) = List.tl _x_0 in let (_x_9 : int) = _x_5 - _x_6 in let (_x_10 : order list) = List.tl _x_3 in let (_x_11 : int) = (_x_1.o_price + _x_4.o_price) / 2 in let (_x_12 : fill list) = if not _x_1.o_is_implied then {fill_client_id = _x_1.o_client_id; fill_qty = _x_6; fill_price = _x_11; fill_order_id = _x_1.o_id; fill_order_done = true} :: fills else fills in uncross_book {b_buys = if _x_7 = 0 then _x_8 else {_x_1 with o_qty = _x_7} :: _x_8; b_sells = if _x_9 = 0 then _x_10 else {_x_4 with o_qty = _x_9} :: _x_10} (if not _x_4.o_is_implied then {fill_client_id = _x_4.o_client_id; fill_qty = _x_6; fill_price = _x_11; fill_order_id = _x_4.o_id; fill_order_done = true} :: _x_12 else _x_12) (filled_qty + _x_6) ---------------------------------------------------------------------------- original ordinal: book_measure b ---------------------------------------------------------------------------- sub ordinal: let (_x_0 : order list) = b.b_buys in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_qty in let (_x_3 : order list) = b.b_sells in let (_x_4 : order) = List.hd _x_3 in let (_x_5 : int) = _x_4.o_qty in let (_x_6 : int) = if _x_2 < _x_5 then _x_2 else _x_5 in let (_x_7 : int) = _x_2 - _x_6 in let (_x_8 : order list) = List.tl _x_0 in let (_x_9 : int) = _x_5 - _x_6 in let (_x_10 : order list) = List.tl _x_3 in book_measure {b_buys = if _x_7 = 0 then _x_8 else {_x_1 with o_qty = _x_7} :: _x_8; b_sells = if _x_9 = 0 then _x_10 else {_x_4 with o_qty = _x_9} :: _x_10} ---------------------------------------------------------------------------- path: [(List.hd b.b_buys).o_price >= (List.hd b.b_sells).o_price && not Is_a([], b.b_buys) && not Is_a([], b.b_sells)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 5 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.047s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 12 ---------------------------------------------------------------------------- arith-assume-eqs: 20 ---------------------------------------------------------------------------- arith-make-feasible: 102 ---------------------------------------------------------------------------- arith-max-columns: 43 ---------------------------------------------------------------------------- arith-conflicts: 3 ---------------------------------------------------------------------------- rlimit count: 34965 ---------------------------------------------------------------------------- arith-cheap-eqs: 48 ---------------------------------------------------------------------------- mk clause: 184 ---------------------------------------------------------------------------- datatype occurs check: 116 ---------------------------------------------------------------------------- mk bool var: 805 ---------------------------------------------------------------------------- arith-lower: 73 ---------------------------------------------------------------------------- arith-diseq: 18 ---------------------------------------------------------------------------- datatype splits: 168 ---------------------------------------------------------------------------- decisions: 216 ---------------------------------------------------------------------------- arith-propagations: 8 ---------------------------------------------------------------------------- propagations: 176 ---------------------------------------------------------------------------- interface eqs: 20 ---------------------------------------------------------------------------- arith-bound-propagations-cheap: 8 ---------------------------------------------------------------------------- arith-max-rows: 22 ---------------------------------------------------------------------------- conflicts: 24 ---------------------------------------------------------------------------- datatype accessor ax: 102 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 6 ---------------------------------------------------------------------------- datatype constructor ax: 280 ---------------------------------------------------------------------------- num allocs: 21720171 ---------------------------------------------------------------------------- final checks: 31 ---------------------------------------------------------------------------- added eqs: 1436 ---------------------------------------------------------------------------- del clause: 166 ---------------------------------------------------------------------------- arith eq adapter: 74 ---------------------------------------------------------------------------- arith-upper: 86 ---------------------------------------------------------------------------- time: 0.001000 ---------------------------------------------------------------------------- memory: 11.090000 ---------------------------------------------------------------------------- max memory: 11.090000 } } }) (full: * ```start[0.047s] let (_x_0 : order list) = b.b_buys in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_price in let (_x_3 : order list) = b.b_sells in let (_x_4 : order) = List.hd _x_3 in let (_x_5 : int) = _x_4.o_price in let (_x_6 : int) = List.length _x_0 + List.length _x_3 in let (_x_7 : int) = if _x_6 >= 0 then _x_6 else 0 in let (_x_8 : int) = List.length ….b_buys + List.length ….b_sells in let (_x_9 : int) = if _x_8 >= 0 then _x_8 else 0 in let (_x_10 : int) = _x_1.o_qty in let (_x_11 : int) = _x_4.o_qty in let (_x_12 : int) = if _x_10 < _x_11 then _x_10 else _x_11 in let (_x_13 : int) = _x_10 - _x_12 in let (_x_14 : order list) = List.tl _x_0 in let (_x_15 : order list) = if _x_13 = 0 then _x_14 else {o_qty = _x_13; o_price = _x_2; o_time = _x_1.o_time; o_id = _x_1.o_id; o_side = _x_1.o_side; o_client_id = _x_1.o_client_id; o_inst = _x_1.o_inst; o_is_implied = _x_1.o_is_implied} :: _x_14 in let (_x_16 : int) = _x_11 - _x_12 in let (_x_17 : order list) = List.tl _x_3 in let (_x_18 : order list) = if _x_16 = 0 then _x_17 else {o_qty = _x_16; o_price = _x_5; o_time = …; o_id = …; o_side = …; o_client_id = …; o_inst = …; o_is_implied = …} :: _x_17 in _x_2 >= _x_5 && not Is_a([], _x_0) && not Is_a([], _x_3) && _x_7 >= 0 && _x_9 >= 0 ==> not ((List.hd _x_15).o_price >= (List.hd _x_18).o_price && not Is_a([], _x_15) && not Is_a([], _x_18)) || Ordinal.( << ) (Ordinal.Int _x_9) (Ordinal.Int _x_7)``` * simplify:: {into: ```let (_x_0 : order list) = b.b_buys in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_price in let (_x_3 : order list) = b.b_sells in let (_x_4 : order) = List.hd _x_3 in let (_x_5 : int) = _x_1.o_qty in let (_x_6 : int) = _x_4.o_qty in let (_x_7 : int) = (-1) * (if _x_6 <= _x_5 then _x_6 else _x_5) in let (_x_8 : int) = _x_5 + _x_7 in let (_x_9 : order list) = List.tl _x_0 in let (_x_10 : order list) = if _x_8 = 0 then _x_9 else {o_qty = _x_8; o_price = _x_2; o_time = _x_1.o_time; o_id = _x_1.o_id; o_side = _x_1.o_side; o_client_id = _x_1.o_client_id; o_inst = _x_1.o_inst; o_is_implied = _x_1.o_is_implied} :: _x_9 in let (_x_11 : order list) = if _x_6 + _x_7 = 0 then List.tl _x_3 else … in let (_x_12 : int) = List.length _x_10 + List.length _x_11 in let (_x_13 : int) = List.length _x_0 + List.length _x_3 in (not ((_x_2 >= _x_4.o_price && not Is_a([], _x_0)) && not Is_a([], _x_3)) || Ordinal.( << ) (Ordinal.Int (if _x_12 >= 0 then _x_12 else 0)) (Ordinal.Int (if _x_13 >= 0 then _x_13 else 0))) || not (((List.hd _x_10).o_price >= (List.hd _x_11).o_price && not Is_a([], _x_10)) && not Is_a([], _x_11))``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|List.length_2124| (b_sells_89 b_2132))` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|List.length_2124| (b_buys_88 b_2132))` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(let ((a!1 (<= (o_qty_68 (|get.::.0_1821| (b_sells_89 b_2132))) (o_qty_68 (|get.::.0_…``` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(let ((a!1 (<= (o_qty_68 (|get.::.0_1821| (b_sells_89 b_2132))) (o_qty_68 (|get.::.0_…``` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(let ((a!1 (<= (o_qty_68 (|get.::.0_1821| (b_sells_89 b_2132))) (o_qty_68 (|get.::.0_…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }

We now have a function that does something real - uncross_book (b : book) (fills : fill list) (filled_qty : int). Let's experiment how it works with some concrete values.

Try this!
In [6]:
let book1 = {
  b_buys = [
    (make BUY 100 55 1 (Outright OUT1) 1 false 1)
    ; (make BUY 100 50 2 (Outright OUT1) 1 false 1)
    ]
 ; b_sells = [
    (make BUY 100 54 3 (Outright OUT1) 1 false 1)
    ; (make BUY 100 54 4 (Outright OUT1) 1 false 1)
  ]
} in

uncross_book book1 [] 0
Out[6]:
- : uncross_res =
{uncrossed_book =
  {b_buys =
    [{o_qty = 100; o_price = 50; o_time = 1; o_id = 2; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
   b_sells =
    [{o_qty = 100; o_price = 54; o_time = 1; o_id = 4; o_side = BUY;
      o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
 uncrossed_fills =
  [{fill_client_id = 1; fill_qty = 100; fill_price = 54; fill_order_id = 3;
    fill_order_done = true};
   {fill_client_id = 1; fill_qty = 100; fill_price = 54; fill_order_id = 1;
    fill_order_done = true}];
 uncrossed_qty = 100}

2.3 A few verification goals

Let's try to verify some verification goals.

The first one will make sure that for an order book that is sorted (so the best bid/ask orders will be the first ones in their respective lists. Note: this is not based on the 'imbalance' of the order book, this is simply taking the midpointt of the most aggressive orders.

Try this!
In [7]:
(* Returns true if the orders are sorted with respect to price *)
let rec side_price_sorted (si : side) (orders : order list) =
  match orders with
  | [] -> true
  | x::[] -> true
  | x::y::xs ->
    if si = BUY then
      begin
        if y.o_price > x.o_price && x.o_price > 0 then false else (side_price_sorted si (y::xs))
      end
    else
      begin
        if y.o_price < x.o_price && y.o_price > 0 then false else (side_price_sorted si (y::xs))
      end
;;

(* Let's make sure all the fills have this price *)
let rec fills_good_price (fills : fill list) (p : int) =
  match fills with
  | [] -> true
  | x::xs -> (x.fill_price = p) && (fills_good_price xs p)
;;

(** Let's to verify some properties *)
let fill_price_midpoint (b : book) =

  let buys_sorted = side_price_sorted BUY b.b_buys in
  let sells_sorted = side_price_sorted SELL b.b_sells in

  let result_good =
    begin
      match b.b_buys, b.b_sells with
      | [], _ -> true
      | _, [] -> true
      | x::xs, y::ys ->
        let unc_res = uncross_book b [] 0 in
        if x.o_price >= y.o_price then
          let midprice = (x.o_price + y.o_price) / 2 in
          (List.length unc_res.uncrossed_fills) > 0 && (fills_good_price unc_res.uncrossed_fills midprice)
        else
          true
    end in

  (* This is the 'punchline'... if the sides are price-sorted, then the fills will be the first midpoint *)
  (buys_sorted && sells_sorted) ==> result_good
;;


verify fill_price_midpoint
Out[7]:
val side_price_sorted : side -> order list -> bool = <fun>
val fills_good_price : fill list -> Z.t -> bool = <fun>
val fill_price_midpoint : book -> bool = <fun>
- : book -> bool = <fun>
module CX : sig val b : book end
termination proof

Termination proof

call `let (_x_0 : order list) = List.tl orders in side_price_sorted si ((List.hd _x_0) :: (List.tl _x_0))` from `side_price_sorted si orders`
{original: side_price_sorted si orders ---------------------------------------------------------------------------- sub: let (_x_0 : order list) = List.tl orders in side_price_sorted si ((List.hd _x_0) :: (List.tl _x_0)) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: let (_x_0 : order list) = List.tl orders in Ordinal.Int (_cnt ((List.hd _x_0) :: (List.tl _x_0))) ---------------------------------------------------------------------------- path: [let (_x_0 : int) = (List.hd orders).o_price in not ((List.hd (List.tl orders)).o_price > _x_0 && _x_0 > 0) && si = BUY && not Is_a([], List.tl orders) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.037s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 14 ---------------------------------------------------------------------------- arith-make-feasible: 101 ---------------------------------------------------------------------------- arith-max-columns: 68 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 48137 ---------------------------------------------------------------------------- arith-cheap-eqs: 46 ---------------------------------------------------------------------------- mk clause: 146 ---------------------------------------------------------------------------- datatype occurs check: 51 ---------------------------------------------------------------------------- mk bool var: 388 ---------------------------------------------------------------------------- arith-lower: 60 ---------------------------------------------------------------------------- datatype splits: 56 ---------------------------------------------------------------------------- decisions: 126 ---------------------------------------------------------------------------- propagations: 95 ---------------------------------------------------------------------------- interface eqs: 14 ---------------------------------------------------------------------------- arith-max-rows: 35 ---------------------------------------------------------------------------- conflicts: 8 ---------------------------------------------------------------------------- datatype accessor ax: 35 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 4 ---------------------------------------------------------------------------- datatype constructor ax: 87 ---------------------------------------------------------------------------- num allocs: 38826699 ---------------------------------------------------------------------------- final checks: 20 ---------------------------------------------------------------------------- added eqs: 461 ---------------------------------------------------------------------------- del clause: 106 ---------------------------------------------------------------------------- arith eq adapter: 52 ---------------------------------------------------------------------------- arith-upper: 87 ---------------------------------------------------------------------------- time: 0.001000 ---------------------------------------------------------------------------- memory: 14.230000 ---------------------------------------------------------------------------- max memory: 16.850000 } } }) (full: * ```start[0.037s] let (_x_0 : order list) = List.tl orders in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_price in let (_x_3 : int) = (List.hd orders).o_price in let (_x_4 : bool) = si = BUY in let (_x_5 : int) = count.list count.order orders in let (_x_6 : int) = count.list count.order (_x_1 :: …) in let (_x_7 : int) = (List.hd …).o_price in let (_x_8 : bool) = not Is_a([], …) in not (_x_2 > _x_3 && _x_3 > 0) && _x_4 && not Is_a([], _x_0) && not Is_a([], orders) && _x_5 >= 0 && _x_6 >= 0 ==> not (not (_x_7 > _x_2 && _x_2 > 0) && _x_4 && _x_8) && not (not (_x_7 < _x_2 && _x_7 > 0) && not _x_4 && _x_8) || Ordinal.( << ) (Ordinal.Int _x_6) (Ordinal.Int _x_5)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl orders in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = count.list count.order (_x_1 :: …) in let (_x_3 : int) = count.list count.order orders in let (_x_4 : int) = (List.hd …).o_price in let (_x_5 : int) = _x_1.o_price in let (_x_6 : bool) = si = BUY in let (_x_7 : bool) = not Is_a([], …) in let (_x_8 : int) = (List.hd orders).o_price in (Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_3) || not ((not (not (_x_4 <= _x_5) && not (_x_5 <= 0)) && _x_6) && _x_7) && not ((not (not (_x_5 <= _x_4) && not (_x_4 <= 0)) && not _x_6) && _x_7)) || not (((((not (not (_x_5 <= _x_8) && not (_x_8 <= 0)) && _x_6) && not Is_a([], _x_0)) && not Is_a([], orders)) && _x_3 >= 0) && _x_2 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(let ((a!1 (|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> i…` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
call `let (_x_0 : order list) = List.tl orders in side_price_sorted si ((List.hd _x_0) :: (List.tl _x_0))` from `side_price_sorted si orders`
{original: side_price_sorted si orders ---------------------------------------------------------------------------- sub: let (_x_0 : order list) = List.tl orders in side_price_sorted si ((List.hd _x_0) :: (List.tl _x_0)) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: let (_x_0 : order list) = List.tl orders in Ordinal.Int (_cnt ((List.hd _x_0) :: (List.tl _x_0))) ---------------------------------------------------------------------------- path: [let (_x_0 : int) = (List.hd (List.tl orders)).o_price in not (_x_0 < (List.hd orders).o_price && _x_0 > 0) && not (si = BUY) && not Is_a([], List.tl orders) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.029s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 12 ---------------------------------------------------------------------------- arith-make-feasible: 80 ---------------------------------------------------------------------------- arith-max-columns: 65 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 41267 ---------------------------------------------------------------------------- arith-cheap-eqs: 20 ---------------------------------------------------------------------------- mk clause: 125 ---------------------------------------------------------------------------- datatype occurs check: 59 ---------------------------------------------------------------------------- mk bool var: 355 ---------------------------------------------------------------------------- arith-lower: 48 ---------------------------------------------------------------------------- datatype splits: 52 ---------------------------------------------------------------------------- decisions: 98 ---------------------------------------------------------------------------- propagations: 77 ---------------------------------------------------------------------------- interface eqs: 12 ---------------------------------------------------------------------------- arith-max-rows: 32 ---------------------------------------------------------------------------- conflicts: 8 ---------------------------------------------------------------------------- datatype accessor ax: 34 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 2 ---------------------------------------------------------------------------- datatype constructor ax: 86 ---------------------------------------------------------------------------- num allocs: 27307609 ---------------------------------------------------------------------------- final checks: 18 ---------------------------------------------------------------------------- added eqs: 417 ---------------------------------------------------------------------------- del clause: 88 ---------------------------------------------------------------------------- arith eq adapter: 40 ---------------------------------------------------------------------------- arith-upper: 66 ---------------------------------------------------------------------------- memory: 14.240000 ---------------------------------------------------------------------------- max memory: 14.240000 } } }) (full: * ```start[0.029s] let (_x_0 : order list) = List.tl orders in let (_x_1 : order) = List.hd _x_0 in let (_x_2 : int) = _x_1.o_price in let (_x_3 : bool) = _x_2 > 0 in let (_x_4 : bool) = si = BUY in let (_x_5 : bool) = not _x_4 in let (_x_6 : int) = count.list count.order orders in let (_x_7 : int) = count.list count.order (_x_1 :: …) in let (_x_8 : int) = (List.hd …).o_price in let (_x_9 : bool) = not Is_a([], …) in not (_x_2 < (List.hd orders).o_price && _x_3) && _x_5 && not Is_a([], _x_0) && not Is_a([], orders) && _x_6 >= 0 && _x_7 >= 0 ==> not (not (_x_8 > _x_2 && _x_3) && _x_4 && _x_9) && not (not (_x_8 < _x_2 && _x_8 > 0) && _x_5 && _x_9) || Ordinal.( << ) (Ordinal.Int _x_7) (Ordinal.Int _x_6)``` * simplify:: {into: ```let (_x_0 : int) = count.list count.order (… :: …) in let (_x_1 : int) = count.list count.order orders in let (_x_2 : int) = (List.hd …).o_price in let (_x_3 : int) = ….o_price in let (_x_4 : bool) = not (_x_3 <= 0) in let (_x_5 : bool) = si = BUY in let (_x_6 : bool) = not Is_a([], …) in let (_x_7 : bool) = not _x_5 in (Ordinal.( << ) (Ordinal.Int _x_0) (Ordinal.Int _x_1) || not ((not (not (_x_2 <= _x_3) && _x_4) && _x_5) && _x_6) && not ((not (not (_x_3 <= _x_2) && not (_x_2 <= 0)) && _x_7) && _x_6)) || not (((((not (not ((List.hd orders).o_price <= _x_3) && _x_4) && _x_7) && not Is_a([], List.tl orders)) && not Is_a([], orders)) && _x_1 >= 0) && _x_0 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/2834 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(let ((a!1 (|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> i…` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `fills_good_price (List.tl fills) p` from `fills_good_price fills p`
{original: fills_good_price fills p ---------------------------------------------------------------------------- sub: fills_good_price (List.tl fills) p ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt fills) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl fills)) ---------------------------------------------------------------------------- path: [(List.hd fills).fill_price = p && not Is_a([], fills)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.028s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 6 ---------------------------------------------------------------------------- arith-make-feasible: 62 ---------------------------------------------------------------------------- arith-max-columns: 43 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 51965 ---------------------------------------------------------------------------- mk clause: 86 ---------------------------------------------------------------------------- datatype occurs check: 27 ---------------------------------------------------------------------------- mk bool var: 152 ---------------------------------------------------------------------------- arith-lower: 35 ---------------------------------------------------------------------------- datatype splits: 3 ---------------------------------------------------------------------------- decisions: 49 ---------------------------------------------------------------------------- propagations: 65 ---------------------------------------------------------------------------- interface eqs: 6 ---------------------------------------------------------------------------- arith-max-rows: 18 ---------------------------------------------------------------------------- conflicts: 8 ---------------------------------------------------------------------------- datatype accessor ax: 9 ---------------------------------------------------------------------------- datatype constructor ax: 7 ---------------------------------------------------------------------------- num allocs: 45325168 ---------------------------------------------------------------------------- final checks: 12 ---------------------------------------------------------------------------- added eqs: 116 ---------------------------------------------------------------------------- del clause: 61 ---------------------------------------------------------------------------- arith eq adapter: 34 ---------------------------------------------------------------------------- arith-upper: 59 ---------------------------------------------------------------------------- memory: 16.980000 ---------------------------------------------------------------------------- max memory: 16.980000 } } }) (full: * ```start[0.028s] let (_x_0 : int) = count.list count.fill fills in let (_x_1 : fill list) = List.tl fills in let (_x_2 : int) = count.list count.fill _x_1 in (List.hd fills).fill_price = p && not Is_a([], fills) && _x_0 >= 0 && _x_2 >= 0 ==> not ((List.hd _x_1).fill_price = p && not Is_a([], _x_1)) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : fill list) = List.tl fills in let (_x_1 : int) = count.list count.fill _x_0 in let (_x_2 : int) = count.list count.fill fills in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not ((((List.hd fills).fill_price = p && not Is_a([], fills)) && _x_2 >= 0) && _x_1 >= 0)) || not ((List.hd _x_0).fill_price = p && not Is_a([], _x_0))``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/2482 }`_1…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
Counterexample (after 6 steps, 0.058s):
let b : book =
  let (_x_0 : instrument) = Strategy STRAT1 in
  {b_buys =
   [{o_qty = 10450; o_price = (-6864); o_time = 21; o_id = 10; o_side = BUY;
     o_client_id = 11; o_inst = _x_0; o_is_implied = true}];
   b_sells =
   [{o_qty = (-1); o_price = (-23594); o_time = 3; o_id = 4; o_side = BUY;
     o_client_id = 5; o_inst = _x_0; o_is_implied = true}]}
Refuted
proof attempt
{ground_instances: 6 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.058s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 13 ---------------------------------------------------------------------------- arith-assume-eqs: 23 ---------------------------------------------------------------------------- arith-make-feasible: 94 ---------------------------------------------------------------------------- arith-max-columns: 48 ---------------------------------------------------------------------------- rlimit count: 15525 ---------------------------------------------------------------------------- arith-gcd-calls: 2 ---------------------------------------------------------------------------- arith-cheap-eqs: 75 ---------------------------------------------------------------------------- mk clause: 279 ---------------------------------------------------------------------------- datatype occurs check: 276 ---------------------------------------------------------------------------- mk bool var: 1171 ---------------------------------------------------------------------------- arith-lower: 82 ---------------------------------------------------------------------------- arith-diseq: 17 ---------------------------------------------------------------------------- datatype splits: 242 ---------------------------------------------------------------------------- decisions: 339 ---------------------------------------------------------------------------- arith-propagations: 10 ---------------------------------------------------------------------------- arith-patches-success: 2 ---------------------------------------------------------------------------- propagations: 281 ---------------------------------------------------------------------------- arith-patches: 2 ---------------------------------------------------------------------------- interface eqs: 23 ---------------------------------------------------------------------------- arith-bound-propagations-cheap: 10 ---------------------------------------------------------------------------- arith-max-rows: 24 ---------------------------------------------------------------------------- conflicts: 13 ---------------------------------------------------------------------------- datatype accessor ax: 150 ---------------------------------------------------------------------------- minimized lits: 2 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 3 ---------------------------------------------------------------------------- datatype constructor ax: 412 ---------------------------------------------------------------------------- num allocs: 60772807 ---------------------------------------------------------------------------- final checks: 38 ---------------------------------------------------------------------------- added eqs: 2105 ---------------------------------------------------------------------------- del clause: 123 ---------------------------------------------------------------------------- arith eq adapter: 67 ---------------------------------------------------------------------------- arith-upper: 72 ---------------------------------------------------------------------------- time: 0.005000 ---------------------------------------------------------------------------- memory: 17.710000 ---------------------------------------------------------------------------- max memory: 17.710000 } } }
Expand
  • start[0.058s]
  let (_x_0 : order list) = ( :var_0: ).b_buys in
  let (_x_1 : order list) = ( :var_0: ).b_sells in
  side_price_sorted BUY _x_0 && side_price_sorted SELL _x_1
  ==> (if Is_a([], _x_0) then true
       else
       if Is_a([], _x_1) then true
       else
       if (List.hd _x_0).o_price >= (List.hd _x_1).o_price
       then List.length … > 0 && fills_good_price … … else true)

  • simplify

    {into: ```let (_x_0 : order list) = ( :var_0: ).b_sells in let (_x_1 : order list) = ( :var_0: ).b_buys in let (_x_2 : fill list) = (uncross_book ( :var_0: ) [] 0).uncrossed_fills in let (_x_3 : int) = (List.hd _x_1).o_price in let (_x_4 : int) = (List.hd _x_0).o_price in (((Is_a([], _x_0) || Is_a([], _x_1)) || not (List.length _x_2 <= 0) && fills_good_price _x_2 ((_x_3 + _x_4) / 2)) || not (_x_3 >= _x_4)) || not (side_price_sorted BUY _x_1 && side_price_sorted SELL _x_0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: }
  • unroll{expr: `(side_price_sorted_289 SELL_16 (b_sells_89 b_332))` ---------------------------------------------------------------------------- expansions: }
  • unroll{expr: `(side_price_sorted_289 BUY_15 (b_buys_88 b_332))` ---------------------------------------------------------------------------- expansions: }
  • unroll{expr: ```(let ((a!1 (+ (o_price_69 (|get.::.0_2517| (b_buys_88 b_332))) (o_price_69 (|get.::.0_…``` ---------------------------------------------------------------------------- expansions: }
  • unroll{expr: `(uncross_book_225 b_332 |[]_2| 0)` ---------------------------------------------------------------------------- expansions: }
  • unroll{expr: `(|List.length_2524| (uncrossed_fills_163 (uncross_book_225 b_332 |[]_2| 0)))` ---------------------------------------------------------------------------- expansions: }
  • unroll{expr: ```(let ((a!1 (<= (o_qty_68 (|get.::.0_2517| (b_sells_89 b_332))) (o_qty_68 (|get.::.0_2…``` ---------------------------------------------------------------------------- expansions: }
  • Sat (Some let b : book = let (_x_0 : instrument) = Strategy STRAT1 in {b_buys = [{o_qty = (Z.of_nativeint (10450n)); o_price = (Z.of_nativeint (-6864n)); o_time = (Z.of_nativeint (21n)); o_id = (Z.of_nativeint (10n)); o_side = BUY; o_client_id = (Z.of_nativeint (11n)); o_inst = _x_0; o_is_implied = true}]; b_sells = [{o_qty = (Z.of_nativeint (-1n)); o_price = (Z.of_nativeint (-23594n)); o_time = (Z.of_nativeint (3n)); o_id = (Z.of_nativeint (4n)); o_side = BUY; o_client_id = (Z.of_nativeint (5n)); o_inst = _x_0; o_is_implied = true}]} )

Our second verification goal will look to make sure that no quantities are lost during uncrossing. Note that no fills are generated for implied orders (there's a different mechanism for that), so when we look at the book we will only consider outright orders. Note that o_qty represents the residual order quantity - for this demo, we do not differentiate between original, filled and residual order quantity. When order is created, the qty is set to that number and is decreased when filled.

Try this!
In [8]:
(* All no quantities get lost during uncross *)
let no_lost_qtys (b : book) =

  let rec qtys_pos_nonimp = function
    | [] -> true
    | x::xs -> x.o_qty >= 0 && not x.o_is_implied && (qtys_pos_nonimp xs) in

  let rec sum_qtys = function
    | [] -> 0
    | x::xs -> x.o_qty + (sum_qtys xs) in

  let rec sum_fill_qtys = function
    | [] -> 0
    | x::xs -> x.fill_qty + (sum_fill_qtys xs) in

  let unc_res = uncross_book b [] 0 in

  (* We need to make sure the book is non-negative *)
  let book_nonneg_nonimp = (qtys_pos_nonimp b.b_buys) && (qtys_pos_nonimp b.b_sells) in

  (* Let's sum up all of the quantities of orders before the uncross *)
  let count_before = (sum_qtys b.b_buys) + (sum_qtys b.b_sells) in

  (* And after *)
  let count_after = (sum_qtys unc_res.uncrossed_book.b_buys) +
                    (sum_qtys unc_res.uncrossed_book.b_sells) +
                    (sum_fill_qtys unc_res.uncrossed_fills) in

  book_nonneg_nonimp ==> (count_before = count_after)
;;

verify ~upto:15 no_lost_qtys
Out[8]:
val no_lost_qtys : book -> bool = <fun>
- : book -> bool = <fun>
termination proof

Termination proof

call `recfun.no_lost_qtys.sum_fill_qtys.2 (List.tl _x30)` from `recfun.no_lost_qtys.sum_fill_qtys.2 _x30`
{original: recfun.no_lost_qtys.sum_fill_qtys.2 _x30 ---------------------------------------------------------------------------- sub: recfun.no_lost_qtys.sum_fill_qtys.2 (List.tl _x30) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt _x30) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl _x30)) ---------------------------------------------------------------------------- path: [not Is_a([], _x30)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.029s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 11 ---------------------------------------------------------------------------- arith-make-feasible: 68 ---------------------------------------------------------------------------- arith-max-columns: 51 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 19321 ---------------------------------------------------------------------------- mk clause: 104 ---------------------------------------------------------------------------- datatype occurs check: 42 ---------------------------------------------------------------------------- mk bool var: 160 ---------------------------------------------------------------------------- arith-lower: 36 ---------------------------------------------------------------------------- datatype splits: 3 ---------------------------------------------------------------------------- decisions: 54 ---------------------------------------------------------------------------- propagations: 63 ---------------------------------------------------------------------------- interface eqs: 11 ---------------------------------------------------------------------------- arith-max-rows: 24 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 9 ---------------------------------------------------------------------------- datatype constructor ax: 7 ---------------------------------------------------------------------------- num allocs: 68997917 ---------------------------------------------------------------------------- final checks: 17 ---------------------------------------------------------------------------- added eqs: 114 ---------------------------------------------------------------------------- del clause: 77 ---------------------------------------------------------------------------- arith eq adapter: 35 ---------------------------------------------------------------------------- arith-upper: 59 ---------------------------------------------------------------------------- memory: 20.600000 ---------------------------------------------------------------------------- max memory: 20.600000 } } }) (full: * ```start[0.029s] let (_x_0 : int) = count.list count.fill _x30 in let (_x_1 : fill list) = List.tl _x30 in let (_x_2 : int) = count.list count.fill _x_1 in not Is_a([], _x30) && _x_0 >= 0 && _x_2 >= 0 ==> Is_a([], _x_1) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : fill list) = List.tl _x30 in let (_x_1 : int) = count.list count.fill _x_0 in let (_x_2 : int) = count.list count.fill _x30 in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || Is_a([], _x_0)) || not ((not Is_a([], _x30) && _x_2 >= 0) && _x_1 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/1172 }`_2…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.fill; spec_ty = (fill -> int)/1172 }`_2…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `recfun.no_lost_qtys.sum_qtys.1 (List.tl _x29)` from `recfun.no_lost_qtys.sum_qtys.1 _x29`
{original: recfun.no_lost_qtys.sum_qtys.1 _x29 ---------------------------------------------------------------------------- sub: recfun.no_lost_qtys.sum_qtys.1 (List.tl _x29) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt _x29) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl _x29)) ---------------------------------------------------------------------------- path: [not Is_a([], _x29)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.029s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 5 ---------------------------------------------------------------------------- arith-make-feasible: 35 ---------------------------------------------------------------------------- arith-max-columns: 39 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 23303 ---------------------------------------------------------------------------- mk clause: 71 ---------------------------------------------------------------------------- datatype occurs check: 31 ---------------------------------------------------------------------------- mk bool var: 230 ---------------------------------------------------------------------------- arith-lower: 18 ---------------------------------------------------------------------------- datatype splits: 39 ---------------------------------------------------------------------------- decisions: 46 ---------------------------------------------------------------------------- propagations: 32 ---------------------------------------------------------------------------- interface eqs: 5 ---------------------------------------------------------------------------- arith-max-rows: 16 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 29 ---------------------------------------------------------------------------- datatype constructor ax: 57 ---------------------------------------------------------------------------- num allocs: 85907873 ---------------------------------------------------------------------------- final checks: 11 ---------------------------------------------------------------------------- added eqs: 261 ---------------------------------------------------------------------------- del clause: 40 ---------------------------------------------------------------------------- arith eq adapter: 16 ---------------------------------------------------------------------------- arith-upper: 26 ---------------------------------------------------------------------------- memory: 20.670000 ---------------------------------------------------------------------------- max memory: 20.670000 } } }) (full: * ```start[0.029s] let (_x_0 : int) = count.list count.order _x29 in let (_x_1 : order list) = List.tl _x29 in let (_x_2 : int) = count.list count.order _x_1 in not Is_a([], _x29) && _x_0 >= 0 && _x_2 >= 0 ==> Is_a([], _x_1) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl _x29 in let (_x_1 : int) = count.list count.order _x29 in let (_x_2 : int) = count.list count.order _x_0 in (Is_a([], _x_0) || not ((not Is_a([], _x29) && _x_1 >= 0) && _x_2 >= 0)) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_1)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1396 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1396 }`…` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
termination proof

Termination proof

call `recfun.no_lost_qtys.qtys_pos_nonimp.0 (List.tl _x28)` from `recfun.no_lost_qtys.qtys_pos_nonimp.0 _x28`
{original: recfun.no_lost_qtys.qtys_pos_nonimp.0 _x28 ---------------------------------------------------------------------------- sub: recfun.no_lost_qtys.qtys_pos_nonimp.0 (List.tl _x28) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt _x28) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl _x28)) ---------------------------------------------------------------------------- path: [not (List.hd _x28).o_is_implied && (List.hd _x28).o_qty >= 0 && not Is_a([], _x28)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.031s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 12 ---------------------------------------------------------------------------- arith-make-feasible: 78 ---------------------------------------------------------------------------- arith-max-columns: 54 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 28138 ---------------------------------------------------------------------------- mk clause: 112 ---------------------------------------------------------------------------- datatype occurs check: 45 ---------------------------------------------------------------------------- mk bool var: 279 ---------------------------------------------------------------------------- arith-lower: 42 ---------------------------------------------------------------------------- datatype splits: 39 ---------------------------------------------------------------------------- decisions: 71 ---------------------------------------------------------------------------- propagations: 65 ---------------------------------------------------------------------------- interface eqs: 12 ---------------------------------------------------------------------------- arith-max-rows: 25 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 29 ---------------------------------------------------------------------------- datatype constructor ax: 57 ---------------------------------------------------------------------------- num allocs: 104857698 ---------------------------------------------------------------------------- final checks: 18 ---------------------------------------------------------------------------- added eqs: 300 ---------------------------------------------------------------------------- del clause: 89 ---------------------------------------------------------------------------- arith eq adapter: 40 ---------------------------------------------------------------------------- arith-upper: 69 ---------------------------------------------------------------------------- memory: 20.770000 ---------------------------------------------------------------------------- max memory: 23.320000 } } }) (full: * ```start[0.031s] let (_x_0 : order) = List.hd _x28 in let (_x_1 : int) = count.list count.order _x28 in let (_x_2 : order list) = List.tl _x28 in let (_x_3 : int) = count.list count.order _x_2 in let (_x_4 : order) = List.hd _x_2 in not _x_0.o_is_implied && _x_0.o_qty >= 0 && not Is_a([], _x28) && _x_1 >= 0 && _x_3 >= 0 ==> not (not _x_4.o_is_implied && _x_4.o_qty >= 0 && not Is_a([], _x_2)) || Ordinal.( << ) (Ordinal.Int _x_3) (Ordinal.Int _x_1)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl _x28 in let (_x_1 : int) = count.list count.order _x_0 in let (_x_2 : int) = count.list count.order _x28 in let (_x_3 : order) = List.hd _x_0 in let (_x_4 : order) = List.hd _x28 in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not ((not _x_3.o_is_implied && _x_3.o_qty >= 0) && not Is_a([], _x_0))) || not ((((not _x_4.o_is_implied && _x_4.o_qty >= 0) && not Is_a([], _x28)) && _x_2 >= 0) && _x_1 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1396 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1396 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
Proved up to 15 steps

2.4 Test generation

First, we will decompose the function and then generate test cases for it.

Try this!
In [9]:
(* This is a 'side_condition' function that tells decomposition that we're only interested in cases where the
initial fills are empty *)
let cond (b : book) (fills : fill list) (filled_qty : int) =
 fills = [] && filled_qty = 0
;;

let d = Modular_decomp.top ~assuming:"cond" "uncross_book" ~prune:true [@@program];;
Out[9]:
val cond : book -> fill list -> Z.t -> bool = <fun>
Error: uncaught exception:
Stack overflow
Try this!
In [10]:
(* Now let's try to generate some test cases *)

(* This will auto-generate model extractor *)
Extract.eval ~quiet:true ~signature:(Event.DB.fun_id_of_str (db()) "uncross_book") ();;

#remove_doc doc_of_book;;
#remove_doc doc_of_order;;
Modular_decomp.get_regions d |> CCList.map (fun r -> r |> Modular_decomp.get_model |> Mex.of_model);;
#install_doc doc_of_order;;
#install_doc doc_of_book;;
Out[10]:
- : unit = ()
Unbound value doc_pp_doc_of_book.
Unbound value doc_pp_doc_of_book.
Unbound value doc_pp_doc_of_order.
Unbound value doc_pp_doc_of_order.
File "jupyter cell 10", line 8, characters 27-28:
Error: Unbound value d
Line 2, characters 18-30:
2 |           let d = doc_of_order x in
                      ^^^^^^^^^^^^
Error: Unbound value doc_of_order
Line 2, characters 18-29:
2 |           let d = doc_of_book x in
                      ^^^^^^^^^^^
Error: Unbound value doc_of_book

3 Implied trading

3.1 Strategy ranking

When generating implied orders for strategies, there's a criteria used to rank strategies - this section encodes the comparison function.

Try this!
In [11]:
(* Calculate somehow how big the ratio is *)
let leg_ratio (s : strategy) =
  let abs x = if x < 0 then -x else x in
  (abs s.leg1.leg_mult) + (abs s.leg2.leg_mult) + (abs s.leg3.leg_mult)
;;

(* Nearest time to expiry *)
let nearest_time_to_exp (s : strategy) =
  let exp =
    if (month_to_int (contract_expiry s.leg1.leg_sec_idx)) < (month_to_int (contract_expiry s.leg2.leg_sec_idx)) then
      contract_expiry s.leg1.leg_sec_idx
    else
      contract_expiry s.leg2.leg_sec_idx in

  if (month_to_int exp) < (month_to_int (contract_expiry s.leg2.leg_sec_idx)) then
    exp
  else
    contract_expiry s.leg2.leg_sec_idx
;;

(* Return true if s1 should implied uncross before s2 *)
let priority_strat (s1 : strategy) (s2 : strategy) =
  (*
    1. time to expiry of the nearest leg
    2. strategy types (strategies with the greater leg ratio executed first)
    3. strategy creation times *)
  if (month_to_int (nearest_time_to_exp s1)) < (month_to_int (nearest_time_to_exp s2)) then
    true
  else
    if (leg_ratio s1) > (leg_ratio s2) then
      true
    else
      s1.time_created <= s2.time_created
Out[11]:
val leg_ratio : strategy -> Z.t = <fun>
val nearest_time_to_exp : strategy -> month = <fun>
val priority_strat : strategy -> strategy -> bool = <fun>
Try this!
In [12]:
let transitivity s1 s2 s3 =
 ((priority_strat s1 s2) && (priority_strat s2 s3)) ==> (priority_strat s1 s3)

verify transitivity
Out[12]:
val transitivity : strategy -> strategy -> strategy -> bool = <fun>
- : strategy -> strategy -> strategy -> bool = <fun>
module CX : sig val s1 : strategy val s2 : strategy val s3 : strategy end

Counterexample (after 0 steps, 0.032s):
let s1 : strategy =
  let (_x_0 : leg) = {leg_sec_idx = OUT3; leg_mult = 0} in
  {time_created = 0; leg1 = _x_0; leg2 = _x_0;
   leg3 = {leg_sec_idx = OUT1; leg_mult = 1}}
let s2 : strategy =
  let (_x_0 : leg) = {leg_sec_idx = OUT1; leg_mult = 0} in
  {time_created = 281; leg1 = _x_0;
   leg2 = {leg_sec_idx = OUT3; leg_mult = 0}; leg3 = _x_0}
let s3 : strategy =
  {time_created = (-1); leg1 = {leg_sec_idx = OUT3; leg_mult = 0};
   leg2 = {leg_sec_idx = OUT3; leg_mult = 1};
   leg3 = {leg_sec_idx = OUT1; leg_mult = 0}}
Refuted
proof attempt
{ground_instances: 0 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.032s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 1 ---------------------------------------------------------------------------- arith-assume-eqs: 8 ---------------------------------------------------------------------------- arith-make-feasible: 426 ---------------------------------------------------------------------------- arith-max-columns: 76 ---------------------------------------------------------------------------- arith-conflicts: 6 ---------------------------------------------------------------------------- rlimit count: 24124 ---------------------------------------------------------------------------- arith-cheap-eqs: 87 ---------------------------------------------------------------------------- mk clause: 732 ---------------------------------------------------------------------------- datatype occurs check: 32 ---------------------------------------------------------------------------- mk bool var: 979 ---------------------------------------------------------------------------- arith-lower: 292 ---------------------------------------------------------------------------- arith-diseq: 72 ---------------------------------------------------------------------------- datatype splits: 74 ---------------------------------------------------------------------------- decisions: 740 ---------------------------------------------------------------------------- arith-propagations: 124 ---------------------------------------------------------------------------- propagations: 1156 ---------------------------------------------------------------------------- interface eqs: 8 ---------------------------------------------------------------------------- arith-bound-propagations-cheap: 124 ---------------------------------------------------------------------------- arith-max-rows: 38 ---------------------------------------------------------------------------- conflicts: 38 ---------------------------------------------------------------------------- datatype accessor ax: 19 ---------------------------------------------------------------------------- minimized lits: 2 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 7 ---------------------------------------------------------------------------- datatype constructor ax: 140 ---------------------------------------------------------------------------- num allocs: 157401244 ---------------------------------------------------------------------------- final checks: 9 ---------------------------------------------------------------------------- added eqs: 1634 ---------------------------------------------------------------------------- del clause: 307 ---------------------------------------------------------------------------- arith eq adapter: 308 ---------------------------------------------------------------------------- arith-upper: 515 ---------------------------------------------------------------------------- time: 0.020000 ---------------------------------------------------------------------------- memory: 24.410000 ---------------------------------------------------------------------------- max memory: 25.220000 } } }
Expand
  • start[0.032s]
  let (_x_0 : int) = ( :var_0: ).time_created in
  let (_x_1 : int) = ( :var_1: ).time_created in
  let (_x_2 : leg) = ( :var_0: ).leg1 in
  let (_x_3 : int) = _x_2.leg_mult in
  let (_x_4 : leg) = ( :var_0: ).leg2 in
  let (_x_5 : int) = _x_4.leg_mult in
  let (_x_6 : int) = ( :var_0: ).leg3.leg_mult in
  let (_x_7 : int)
      = (if _x_3 < 0 then ~- _x_3 else _x_3)
        + (if _x_5 < 0 then ~- _x_5 else _x_5)
        + (if _x_6 < 0 then ~- _x_6 else _x_6)
  in
  let (_x_8 : leg) = ( :var_1: ).leg1 in
  let (_x_9 : int) = _x_8.leg_mult in
  let (_x_10 : leg) = ( :var_1: ).leg2 in
  let (_x_11 : int) = _x_10.leg_mult in
  let (_x_12 : int) = ( :var_1: ).leg3.leg_mult in
  let (_x_13 : int)
      = (if _x_9 < 0 then ~- _x_9 else _x_9)
        + (if _x_11 < 0 then ~- _x_11 else _x_11)
        + (if _x_12 < 0 then ~- _x_12 else _x_12)
  in
  let (_x_14 : outright_id) = _x_4.leg_sec_idx in
  let (_x_15 : bool) = _x_14 = OUT1 in
  let (_x_16 : outright_id) = _x_2.leg_sec_idx in
  let (_x_17 : bool) = _x_16 = OUT2 in
  let (_x_18 : bool) = _x_16 = OUT1 in
  let (_x_19 : month) = if _x_18 then Mar else if _x_17 then Jun else Sep in
  let (_x_20 : bool) = _x_14 = OUT2 in
  let (_x_21 : month) = if _x_15 then Mar else if _x_20 then Jun else Sep in
  let (_x_22 : int)
      = if _x_21 = Mar then 3
        else if _x_21 = Jun then 6 else if _x_21 = Sep then 9 else 12
  in
  let (_x_23 : bool)
      = (if _x_19 = Mar then 3
         else if _x_19 = Jun then 6 else if _x_19 = Sep then 9 else 12)
        < _x_22
  in
  let (_x_24 : month) = if _x_23 then _x_19 else _x_21 in
  let (_x_25 : bool)
      = (if _x_24 = Mar then 3
         else
         if _x_24 = Jun then 6
         else
         if (if _x_23 then if _x_18 then Mar else …
             else if _x_15 then Mar else …)
            = Sep
         then 9 else 12)
        < _x_22
  in
  let (_x_26 : outright_id) = _x_10.leg_sec_idx in
  let (_x_27 : bool) = _x_26 = OUT1 in
  let (_x_28 : outright_id) = _x_8.leg_sec_idx in
  let (_x_29 : bool) = _x_28 = OUT1 in
  let (_x_30 : bool) = _x_28 = OUT2 in
  let (_x_31 : month) = if _x_29 then Mar else if _x_30 then … else … in
  let (_x_32 : bool) = _x_26 = OUT2 in
  let (_x_33 : month) = if _x_27 then Mar else if _x_32 then … else … in
  let (_x_34 : int)
      = if _x_33 = Mar then 3
        else
        if _x_33 = … then 6
        else if (if _x_27 then Mar else …) = … then 9 else 12
  in
  let (_x_35 : bool)
      = (if _x_31 = Mar then 3
         else
         if _x_31 = … then 6
         else if (if _x_29 then Mar else …) = … then 9 else 12)
        < _x_34
  in
  let (_x_36 : bool)
      = (if (if _x_35 then _x_31 else _x_33) = Mar then 3
         else
         if (if _x_35 then if _x_29 then Mar else …
             else if _x_27 then Mar else …)
            = …
         then 6 else if (if _x_35 then … else …) = … then 9 else 12)
        < _x_34
  in
  let (_x_37 : month) = if _x_29 then Mar else if _x_30 then Jun else Sep in
  let (_x_38 : month) = if _x_27 then Mar else if _x_32 then Jun else Sep in
  let (_x_39 : int)
      = if _x_38 = Mar then 3
        else if _x_38 = Jun then 6 else if _x_38 = Sep then 9 else 12
  in
  let (_x_40 : bool)
      = (if _x_37 = Mar then 3
         else if _x_37 = Jun then 6 else if _x_37 = Sep then 9 else 12)
        < _x_39
  in
  let (_x_41 : month) = if _x_40 then _x_37 else _x_38 in
  let (_x_42 : int)
      = if (if (if _x_41 = Mar then 3
                else
                if _x_41 = Jun then 6
                else
                if (if _x_40 then if _x_29 then Mar else …
                    else if _x_27 then Mar else …)
                   = Sep
                then 9 else 12)
               < _x_39
            then if _x_40 then _x_31 else _x_33 else _x_33)
           = Mar
        then 3
        else
        if (if _x_36
            then
              if _x_35 then if _x_29 then Mar else …
              else if _x_27 then Mar else …
            else _x_33)
           = …
        then 6
        else
        if (if _x_36 then if _x_35 then … else …
            else if _x_27 then Mar else …)
           = …
        then 9 else 12
  in
  let (_x_43 : int) = ( :var_2: ).time_created in
  let (_x_44 : leg) = ( :var_2: ).leg1 in
  let (_x_45 : int) = _x_44.leg_mult in
  let (_x_46 : leg) = ( :var_2: ).leg2 in
  let (_x_47 : int) = _x_46.leg_mult in
  let (_x_48 : int) = ( :var_2: ).leg3.leg_mult in
  let (_x_49 : int)
      = (if _x_45 < 0 then ~- _x_45 else _x_45)
        + (if _x_47 < 0 then ~- _x_47 else _x_47)
        + (if _x_48 < 0 then ~- _x_48 else _x_48)
  in
  let (_x_50 : outright_id) = _x_46.leg_sec_idx in
  let (_x_51 : bool) = _x_50 = OUT1 in
  let (_x_52 : outright_id) = _x_44.leg_sec_idx in
  let (_x_53 : bool) = _x_52 = OUT1 in
  let (_x_54 : month)
      = if _x_53 then Mar else if _x_52 = OUT2 then … else …
  in
  let (_x_55 : month)
      = if _x_51 then Mar else if _x_50 = OUT2 then … else …
  in
  let (_x_56 : int)
      = if _x_55 = Mar then 3
        else if _x_55 = … then 6 else if _x_55 = … then 9 else 12
  in
  let (_x_57 : bool)
      = (if _x_54 = Mar then 3
         else if _x_54 = … then 6 else if _x_54 = … then 9 else 12)
        < _x_56
  in
  let (_x_58 : month) = if _x_57 then _x_54 else _x_55 in
  let (_x_59 : bool)
      = (if _x_58 = Mar then 3
         else
         if _x_58 = … then 6
         else
         if (if _x_57 then if _x_53 then Mar else …
             else if _x_51 then Mar else …)
            = …
         then 9 else 12)
        < _x_56
  in
  let (_x_60 : int)
      = if (if _x_59 then _x_58 else _x_55) = Mar then 3
        else
        if (if _x_59
            then
              if _x_57 then if _x_53 then Mar else …
              else if _x_51 then Mar else …
            else _x_55)
           = …
        then 6
        else
        if (if _x_59 then if _x_57 then … else …
            else if _x_51 then Mar else …)
           = …
        then 9 else 12
  in
  let (_x_61 : month) = if _x_18 then Mar else if _x_17 then … else … in
  let (_x_62 : month) = if _x_15 then Mar else if _x_20 then … else … in
  let (_x_63 : int)
      = if _x_62 = Mar then 3
        else if _x_62 = … then 6 else if _x_62 = … then 9 else 12
  in
  let (_x_64 : bool)
      = (if _x_61 = Mar then 3
         else if _x_61 = … then 6 else if _x_61 = … then 9 else 12)
        < _x_63
  in
  let (_x_65 : month) = if _x_64 then _x_61 else _x_62 in
  let (_x_66 : bool)
      = (if _x_65 = Mar then 3
         else
         if _x_65 = … then 6
         else
         if (if _x_64 then if _x_18 then Mar else …
             else if _x_15 then Mar else …)
            = …
         then 9 else 12)
        < _x_63
  in
  (if (if (if _x_25 then _x_24 else _x_21) = Mar then 3
       else
       if (if _x_25
           then
             if _x_23 then if _x_18 then Mar else …
             else if _x_15 then Mar else …
           else _x_21)
          = Jun
       then 6
       else
       if (if _x_25 then if _x_23 then … else …
           else if _x_15 then Mar else …)
          = Sep
       then 9 else 12)
      < _x_42
   then true else if _x_7 > _x_13 then true else _x_0 <= _x_1)
  && (if _x_42 < _x_60 then true
      else if _x_13 > _x_49 then true else _x_1 <= _x_43)
  ==> (if (if (if _x_66 then _x_65 else _x_62) = Mar then 3
           else
           if (if _x_66
               then
                 if _x_64 then if _x_18 then Mar else …
                 else if _x_15 then Mar else …
               else _x_62)
              = …
           then 6
           else
           if (if _x_66 then if _x_64 then … else …
               else if _x_15 then Mar else …)
              = …
           then 9 else 12)
          < _x_60
       then true else if _x_7 > _x_49 then true else _x_0 <= _x_43)

  • simplify

    {into: ```let (_x_0 : int) = ( :var_0: ).time_created in let (_x_1 : int) = ( :var_2: ).time_created in let (_x_2 : leg) = ( :var_2: ).leg1 in let (_x_3 : outright_id) = _x_2.leg_sec_idx in let (_x_4 : bool) = _x_3 = OUT1 in let (_x_5 : leg) = ( :var_2: ).leg2 in let (_x_6 : outright_id) = _x_5.leg_sec_idx in let (_x_7 : bool) = _x_6 = OUT1 in let (_x_8 : month) = if _x_7 then Mar else if _x_6 = OUT2 then Jun else Sep in let (_x_9 : int) = if _x_8 = Mar then 3 else if _x_8 = Jun then 6 else if _x_8 = Sep then 9 else 12 in let (_x_10 : month) = if _x_4 then Mar else if _x_3 = OUT2 then Jun else Sep in let (_x_11 : bool) = _x_9 <= (if _x_10 = Mar then 3 else if _x_10 = Jun then 6 else if _x_10 = Sep then 9 else 12) in let (_x_12 : month) = if _x_11 then _x_8 else _x_10 in let (_x_13 : bool) = _x_11 || _x_9 <= (if _x_12 = Mar then 3 else if _x_12 = Jun then 6 else if (if _x_11 then if _x_7 then Mar else … else if _x_4 then Mar else …) = Sep then 9 else 12) in let (_x_14 : month) = if _x_13 then _x_8 else _x_10 in let (_x_15 : int) = if _x_14 = Mar then 3 else if _x_14 = Jun then 6 else if (if _x_13 then if _x_7 then Mar else … else if _x_4 then Mar else …) = Sep then 9 else 12 in let (_x_16 : leg) = ( :var_0: ).leg1 in let (_x_17 : outright_id) = _x_16.leg_sec_idx in let (_x_18 : bool) = _x_17 = OUT1 in let (_x_19 : leg) = ( :var_0: ).leg2 in let (_x_20 : outright_id) = _x_19.leg_sec_idx in let (_x_21 : bool) = _x_20 = OUT1 in let (_x_22 : month) = if _x_21 then Mar else if _x_20 = OUT2 then Jun else Sep in let (_x_23 : int) = if _x_22 = Mar then 3 else if _x_22 = Jun then 6 else if _x_22 = Sep then 9 else 12 in let (_x_24 : month) = if _x_18 then Mar else if _x_17 = OUT2 then Jun else Sep in let (_x_25 : bool) = _x_23 <= (if _x_24 = Mar then 3 else if _x_24 = Jun then 6 else if _x_24 = Sep then 9 else 12) in let (_x_26 : month) = if _x_25 then _x_22 else _x_24 in let (_x_27 : bool) = _x_25 || _x_23 <= (if _x_26 = Mar then 3 else if _x_26 = Jun then 6 else if (if _x_25 then if _x_21 then Mar else … else if _x_18 then Mar else …) = Sep then 9 else 12) in let (_x_28 : month) = if _x_27 then _x_22 else _x_24 in let (_x_29 : int) = if _x_28 = Mar then 3 else if _x_28 = Jun then 6 else if (if _x_27 then if _x_21 then Mar else … else if _x_18 then Mar else …) = Sep then 9 else 12 in let (_x_30 : int) = _x_16.leg_mult in let (_x_31 : int) = _x_19.leg_mult in let (_x_32 : int) = ( :var_0: ).leg3.leg_mult in let (_x_33 : int) = (if 0 <= _x_30 then _x_30 else (-1) * _x_30) + (if 0 <= _x_31 then _x_31 else (-1) * _x_31) + (if 0 <= _x_32 then _x_32 else (-1) * _x_32) in let (_x_34 : int) = _x_2.leg_mult in let (_x_35 : int) = _x_5.leg_mult in let (_x_36 : int) = ( :var_2: ).leg3.leg_mult in let (_x_37 : int) = (if 0 <= _x_34 then _x_34 else (-1) * _x_34) + (if 0 <= _x_35 then _x_35 else (-1) * _x_35) + (if 0 <= _x_36 then _x_36 else (-1) * _x_36) in let (_x_38 : int) = ( :var_1: ).time_created in let (_x_39 : leg) = ( :var_1: ).leg1 in let (_x_40 : outright_id) = _x_39.leg_sec_idx in let (_x_41 : bool) = _x_40 = OUT1 in let (_x_42 : leg) = ( :var_1: ).leg2 in let (_x_43 : outright_id) = _x_42.leg_sec_idx in let (_x_44 : bool) = _x_43 = OUT1 in let (_x_45 : month) = if _x_44 then Mar else if _x_43 = OUT2 then Jun else Sep in let (_x_46 : int) = if _x_45 = Mar then 3 else if _x_45 = Jun then 6 else if _x_45 = Sep then 9 else 12 in let (_x_47 : month) = if _x_41 then Mar else if _x_40 = OUT2 then Jun else Sep in let (_x_48 : bool) = _x_46 <= (if _x_47 = Mar then 3 else if _x_47 = Jun then 6 else if _x_47 = Sep then 9 else 12) in let (_x_49 : month) = if _x_48 then _x_45 else _x_47 in let (_x_50 : bool) = _x_48 || _x_46 <= (if _x_49 = Mar then 3 else if _x_49 = Jun then 6 else if (if _x_48 then if _x_44 then Mar else … else if _x_41 then Mar else …) = Sep then 9 else 12) in let (_x_51 : month) = if _x_50 then _x_45 else _x_47 in let (_x_52 : int) = if _x_51 = Mar then 3 else if _x_51 = Jun then 6 else if (if _x_50 then if _x_44 then Mar else … else if _x_41 then Mar else …) = Sep then 9 else 12 in let (_x_53 : int) = _x_39.leg_mult in let (_x_54 : int) = _x_42.leg_mult in let (_x_55 : int) = ( :var_1: ).leg3.leg_mult in let (_x_56 : int) = (if 0 <= _x_53 then _x_53 else (-1) * _x_53) + (if 0 <= _x_54 then _x_54 else (-1) * _x_54) + (if 0 <= _x_55 then _x_55 else (-1) * _x_55) in ((_x_0 <= _x_1 || not (_x_15 <= _x_29)) || not (_x_33 <= _x_37)) || not (((_x_0 <= _x_38 || not (_x_52 <= _x_29)) || not (_x_33 <= _x_56)) && ((_x_38 <= _x_1 || not (_x_15 <= _x_52)) || not (_x_56 <= _x_37)))``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: }
  • Sat (Some let s1 : strategy = let (_x_0 : leg) = {leg_sec_idx = OUT3; leg_mult = (Z.of_nativeint (0n))} in {time_created = (Z.of_nativeint (0n)); leg1 = _x_0; leg2 = _x_0; leg3 = {leg_sec_idx = OUT1; leg_mult = (Z.of_nativeint (1n))}} let s2 : strategy = let (_x_0 : leg) = {leg_sec_idx = OUT1; leg_mult = (Z.of_nativeint (0n))} in {time_created = (Z.of_nativeint (281n)); leg1 = _x_0; leg2 = {leg_sec_idx = OUT3; leg_mult = (Z.of_nativeint (0n))}; leg3 = _x_0} let s3 : strategy = {time_created = (Z.of_nativeint (-1n)); leg1 = {leg_sec_idx = OUT3; leg_mult = (Z.of_nativeint (0n))}; leg2 = {leg_sec_idx = OUT3; leg_mult = (Z.of_nativeint (1n))}; leg3 = {leg_sec_idx = OUT1; leg_mult = (Z.of_nativeint (0n))}} )

Ooops! It seems that our ranking criteria is not transitive. Let's check the results (note that the counter examples are now reflected into the run time in the CX module)

Try this!
In [13]:
priority_strat CX.s1 CX.s2
Out[13]:
- : bool = true
Try this!
In [14]:
priority_strat CX.s2 CX.s3
Out[14]:
- : bool = true
Try this!
In [15]:
priority_strat CX.s1 CX.s3
Out[15]:
- : bool = false

3.2 Implied strategy price calculation

Try this!
In [16]:
(* return the sum of volume at the highest level *)
let rec get_level_sums (orders : order list) (li : level_info option) =
  match orders with
  | [] -> li
  | x::xs ->
    begin
      match li with
      | None -> get_level_sums xs (Some {li_qty = x.o_qty; li_price = x.o_price})
      | Some l ->
        if (l.li_price = x.o_price) then
          get_level_sums xs (Some {l with li_qty = l.li_qty + x.o_qty})
        else
          li
    end

(* Return best bid/ask levels *)
let get_book_tops (b : book) =
  let bid_info = get_level_sums b.b_buys None in
  let ask_info = get_level_sums b.b_sells None in
  { bid_info; ask_info }
;;

(* Get the maximum number of strategy units here *)
(* Note that the units may have different signs, so we
 need to make sure that we have enough *)
let calc_implied_strat_order (sid : strategy_id) (s : strategy) (books : books_info) (si : side) (time : int) =
  let abs x = if x < 0 then -x else x in

  let adjust (mult : int) =
    if si = BUY then mult else -mult in

  (* *)
  let calc_max_out_mult (mult : int) (book : best_bid_ask)  =
    if mult = 0 then
      None
    else
      begin
       if (adjust mult) > 0 then
        match books.book1.bid_info with
           | Some x -> Some (x.li_qty / (abs mult))
           | None -> None
       else
           match book.ask_info with
           | Some x -> Some (x.li_qty / (abs mult))
           | None -> None
      end in

  let mult1 = calc_max_out_mult s.leg1.leg_mult books.book1 in
  let mult2 = calc_max_out_mult s.leg2.leg_mult books.book2 in
  let mult3 = calc_max_out_mult s.leg3.leg_mult books.book3 in

  (* Compute the quantity *)
  let max_strat =
    begin
       match mult1 with
       | None -> 0
       | Some x -> x
    end in
  let max_strat =
    begin
       match mult2 with
       | None -> max_strat
       | Some x -> if x < max_strat then x else max_strat
    end in
  let max_strat =
    begin
     match mult3 with
     | None -> max_strat
     | Some x -> if x < max_strat then x else max_strat
    end in

  (* Now compute the price *)
  let strat_price =
    begin
       match mult1 with
       | None -> 0
       | Some x ->
         begin
            if (adjust s.leg1.leg_mult) > 0 then
                match books.book1.bid_info with
                | Some x -> x.li_price * (adjust s.leg1.leg_mult)
                | None -> 0
            else
                match books.book1.ask_info with
                | Some x -> x.li_price * (adjust s.leg1.leg_mult)
                | None -> 0
         end
    end in
  let strat_price =
    begin
       match mult2 with
       | None -> strat_price
       | Some x ->
         begin
            if (adjust s.leg2.leg_mult) > 0 then
                match books.book2.bid_info with
                | Some x -> x.li_price * (adjust s.leg2.leg_mult) + strat_price
                | None -> strat_price
            else
                match books.book2.ask_info with
                | Some x -> x.li_price * (adjust s.leg2.leg_mult) + strat_price
                | None -> strat_price
         end
    end in
  let strat_price =
    begin
       match mult3 with
       | None -> strat_price
       | Some x ->
         begin
            if (adjust s.leg3.leg_mult) > 0 then
                match books.book3.bid_info with
                | Some x -> x.li_price * (adjust s.leg3.leg_mult) + strat_price
                | None -> strat_price
            else
                match books.book3.ask_info with
                | Some x -> x.li_price * (adjust s.leg3.leg_mult) + strat_price
                | None -> strat_price
         end
    end in

  (* Now form the new implied order here... *)
  {
   o_qty = max_strat
   ; o_price = strat_price
   ; o_id = -1
   ; o_time = time
   ; o_side = si
   ; o_client_id = -1
   ; o_inst = Strategy sid
   ; o_is_implied = true }
;;
Out[16]:
val get_level_sums : order list -> level_info option -> level_info option =
  <fun>
val get_book_tops : book -> best_bid_ask = <fun>
val calc_implied_strat_order :
  strategy_id -> strategy -> books_info -> side -> Z.t -> order = <fun>
termination proof

Termination proof

call `let (_x_0 : order) = List.hd orders in get_level_sums (List.tl orders) (Some {li_qty = _x_0.o_qty; li_price = _x_0.o_price})` from `get_level_sums orders li`
{original: get_level_sums orders li ---------------------------------------------------------------------------- sub: let (_x_0 : order) = List.hd orders in get_level_sums (List.tl orders) (Some {li_qty = _x_0.o_qty; li_price = _x_0.o_price}) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [Is_a(None, li) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.036s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 8 ---------------------------------------------------------------------------- arith-make-feasible: 64 ---------------------------------------------------------------------------- arith-max-columns: 50 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 34027 ---------------------------------------------------------------------------- mk clause: 95 ---------------------------------------------------------------------------- datatype occurs check: 63 ---------------------------------------------------------------------------- mk bool var: 273 ---------------------------------------------------------------------------- arith-lower: 34 ---------------------------------------------------------------------------- datatype splits: 43 ---------------------------------------------------------------------------- decisions: 69 ---------------------------------------------------------------------------- propagations: 63 ---------------------------------------------------------------------------- interface eqs: 8 ---------------------------------------------------------------------------- arith-max-rows: 21 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 32 ---------------------------------------------------------------------------- datatype constructor ax: 60 ---------------------------------------------------------------------------- num allocs: 186319080 ---------------------------------------------------------------------------- final checks: 14 ---------------------------------------------------------------------------- added eqs: 311 ---------------------------------------------------------------------------- del clause: 66 ---------------------------------------------------------------------------- arith eq adapter: 33 ---------------------------------------------------------------------------- arith-upper: 58 ---------------------------------------------------------------------------- memory: 29.930000 ---------------------------------------------------------------------------- max memory: 29.930000 } } }) (full: * ```start[0.036s] let (_x_0 : int) = count.list count.order orders in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = count.list count.order _x_1 in Is_a(None, li) && not Is_a([], orders) && _x_0 >= 0 && _x_2 >= 0 ==> not ((List.hd orders).o_price = (List.hd _x_1).o_price && not Is_a([], _x_1)) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl orders in let (_x_1 : int) = count.list count.order _x_0 in let (_x_2 : int) = count.list count.order orders in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not (((Is_a(None, li) && not Is_a([], orders)) && _x_2 >= 0) && _x_1 >= 0)) || not ((List.hd orders).o_price = (List.hd _x_0).o_price && not Is_a([], _x_0))``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
call `let (_x_0 : level_info) = Option.get li in get_level_sums (List.tl orders) (Some {_x_0 with li_qty = _x_0.li_qty + (List.hd orders).o_qty})` from `get_level_sums orders li`
{original: get_level_sums orders li ---------------------------------------------------------------------------- sub: let (_x_0 : level_info) = Option.get li in get_level_sums (List.tl orders) (Some {_x_0 with li_qty = _x_0.li_qty + (List.hd orders).o_qty}) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [(Option.get li).li_price = (List.hd orders).o_price && not Is_a(None, li) && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.026s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 13 ---------------------------------------------------------------------------- arith-make-feasible: 88 ---------------------------------------------------------------------------- arith-max-columns: 55 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 29308 ---------------------------------------------------------------------------- mk clause: 121 ---------------------------------------------------------------------------- datatype occurs check: 134 ---------------------------------------------------------------------------- mk bool var: 302 ---------------------------------------------------------------------------- arith-lower: 45 ---------------------------------------------------------------------------- datatype splits: 39 ---------------------------------------------------------------------------- decisions: 88 ---------------------------------------------------------------------------- propagations: 74 ---------------------------------------------------------------------------- interface eqs: 13 ---------------------------------------------------------------------------- arith-max-rows: 26 ---------------------------------------------------------------------------- conflicts: 6 ---------------------------------------------------------------------------- datatype accessor ax: 32 ---------------------------------------------------------------------------- datatype constructor ax: 63 ---------------------------------------------------------------------------- num allocs: 171530872 ---------------------------------------------------------------------------- final checks: 19 ---------------------------------------------------------------------------- added eqs: 337 ---------------------------------------------------------------------------- del clause: 92 ---------------------------------------------------------------------------- arith eq adapter: 44 ---------------------------------------------------------------------------- arith-upper: 75 ---------------------------------------------------------------------------- memory: 27.150000 ---------------------------------------------------------------------------- max memory: 27.150000 } } }) (full: * ```start[0.026s] let (_x_0 : int) = (Option.get li).li_price in let (_x_1 : int) = count.list count.order orders in let (_x_2 : order list) = List.tl orders in let (_x_3 : int) = count.list count.order _x_2 in _x_0 = (List.hd orders).o_price && not Is_a(None, li) && not Is_a([], orders) && _x_1 >= 0 && _x_3 >= 0 ==> not (_x_0 = (List.hd _x_2).o_price && not Is_a([], _x_2)) || Ordinal.( << ) (Ordinal.Int _x_3) (Ordinal.Int _x_1)``` * simplify:: {into: ```let (_x_0 : int) = (Option.get li).li_price in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = count.list count.order _x_1 in let (_x_3 : int) = count.list count.order orders in (not (_x_0 = (List.hd _x_1).o_price && not Is_a([], _x_1)) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_3)) || not ((((_x_0 = (List.hd orders).o_price && not Is_a(None, li)) && not Is_a([], orders)) && _x_3 >= 0) && _x_2 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }

Let's now try to experiment with this.

Try this!
In [17]:
let strat1 = {
  time_created = 1;
  leg1    = { leg_sec_idx = OUT1; leg_mult = 1 }
  ; leg2  = { leg_sec_idx = OUT2; leg_mult = 0 }
  ; leg3  = { leg_sec_idx = OUT3; leg_mult = 0 }
};;

let books = {
    book1 = { bid_info = None ; ask_info = Some { li_qty = 100 ; li_price = 450 }}
  ; book2 = { bid_info = Some { li_qty = 125 ; li_price = 100 }; ask_info = Some { li_qty = 100 ; li_price = 350 }}
  ; book3 = { bid_info = None ; ask_info = Some { li_qty = 100 ; li_price = 425 }}
};;

(* This should just replicate the OUT1 security on the SELL side *)
calc_implied_strat_order STRAT1 strat1 books SELL 1
Out[17]:
val strat1 : strategy =
  {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT2; leg_mult = 0};
   leg3 = {leg_sec_idx = OUT3; leg_mult = 0}}
val books : books_info =
  {book1 = {bid_info = None; ask_info = Some {li_qty = 100; li_price = 450}};
   book2 =
    {bid_info = Some {li_qty = 125; li_price = 100};
     ask_info = Some {li_qty = 100; li_price = 350}};
   book3 = {bid_info = None; ask_info = Some {li_qty = 100; li_price = 425}}}
- : order =
{o_qty = 100; o_price = -450; o_time = 1; o_id = -1; o_side = SELL;
 o_client_id = -1; o_inst = Strategy STRAT1; o_is_implied = true}
Try this!
In [18]:
(* Now let's try the same on the BUY side - there should not be any available orders as the bid is empty *)
calc_implied_strat_order STRAT1 strat1 books BUY 1
Out[18]:
- : order =
{o_qty = 0; o_price = 0; o_time = 1; o_id = -1; o_side = BUY;
 o_client_id = -1; o_inst = Strategy STRAT1; o_is_implied = true}
Try this!
In [19]:
(* let's try to mix up the legs now *)

let strat2 = {
 strat1 with
 leg2 = {leg_sec_idx = OUT2; leg_mult = -1}
};;

(* This will not result in any orders because there's no BUY *)
calc_implied_strat_order STRAT1 strat2 books BUY 1
Out[19]:
val strat2 : strategy =
  {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT2; leg_mult = -1};
   leg3 = {leg_sec_idx = OUT3; leg_mult = 0}}
- : order =
{o_qty = 0; o_price = -350; o_time = 1; o_id = -1; o_side = BUY;
 o_client_id = -1; o_inst = Strategy STRAT1; o_is_implied = true}
Try this!
In [20]:
calc_implied_strat_order STRAT2 strat2 books SELL 1
Out[20]:
- : order =
{o_qty = 100; o_price = -450; o_time = 1; o_id = -1; o_side = SELL;
 o_client_id = -1; o_inst = Strategy STRAT2; o_is_implied = true}
Try this!
In [21]:
let strat = {
  time_created = 1;
  leg1    = { leg_sec_idx = OUT1; leg_mult = 1 }
  ; leg2  = { leg_sec_idx = OUT2; leg_mult = -2 }
  ; leg3  = { leg_sec_idx = OUT3; leg_mult = 0 }
};;

let books = {
    book1 = { bid_info = Some { li_qty = 500; li_price = 50 } ; ask_info = Some { li_qty = 750 ; li_price = 50 }}
  ; book2 = { bid_info = Some { li_qty = 200 ; li_price = 60 }; ask_info = Some { li_qty = 500 ; li_price = 70 }}
  ; book3 = { bid_info = None ; ask_info = None }
};;

calc_implied_strat_order STRAT1 strat books BUY 1
Out[21]:
val strat : strategy =
  {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT2; leg_mult = -2};
   leg3 = {leg_sec_idx = OUT3; leg_mult = 0}}
val books : books_info =
  {book1 =
    {bid_info = Some {li_qty = 500; li_price = 50};
     ask_info = Some {li_qty = 750; li_price = 50}};
   book2 =
    {bid_info = Some {li_qty = 200; li_price = 60};
     ask_info = Some {li_qty = 500; li_price = 70}};
   book3 = {bid_info = None; ask_info = None}}
- : order =
{o_qty = 250; o_price = -90; o_time = 1; o_id = -1; o_side = BUY;
 o_client_id = -1; o_inst = Strategy STRAT1; o_is_implied = true}

3.3 Implied uncrossing operations

Try this!
In [22]:
(* removes implied orders from a book *)
let remove_imp_orders (b : book) =
  let rec remove_imp_orders_side (orders : order list) =
    match orders with
    | [] -> []
    | x::xs ->
        if x.o_is_implied then
          (remove_imp_orders_side xs)
        else
          x::(remove_imp_orders_side xs) in

  { b_buys = (remove_imp_orders_side b.b_buys)
  ; b_sells = (remove_imp_orders_side b.b_sells)
  }

(* Allocate implied fills to the book and return fills *)
let allocate_implied_fills (b : book) (qty : int) (price : int) (time : int) =
  if qty = 0 then {
    uncrossed_book = b
    ; uncrossed_fills = []
    ; uncrossed_qty = 0
  } else
  begin
    (* Insert new order into the book and uncross it *)
    let new_order = {
      o_qty = if qty < 0 then (-qty) else qty
      ; o_price = price
      ; o_id = -1
      ; o_time = time
      ; o_side = if qty < 0 then SELL else BUY
      ; o_client_id = -1
      ; o_inst = Outright OUT1
      ; o_is_implied = true
    } in

    (* create new order that we will trade *)
    let b' = insert_order new_order b in

    (* finally we will uncross the book and return results *)
    (uncross_book b' [] 0)
  end

(* Calculate the price at which implied orders should trade in the outright books *)
let calc_implied_trade_price (mult : int) (bidask : best_bid_ask) =
  if mult > 0 then
   begin
    match bidask.ask_info with
      | None -> 0
      | Some x -> x.li_price
    end
  else
    begin
        match bidask.bid_info with
          | None -> 0
          | Some x -> x.li_price
    end
;;
Out[22]:
val remove_imp_orders : book -> book = <fun>
val allocate_implied_fills : book -> Z.t -> Z.t -> Z.t -> uncross_res = <fun>
val calc_implied_trade_price : Z.t -> best_bid_ask -> Z.t = <fun>
termination proof

Termination proof

call `recfun.remove_imp_orders.remove_imp_orders_side.0 (List.tl orders)` from `recfun.remove_imp_orders.remove_imp_orders_side.0 orders`
{original: recfun.remove_imp_orders.remove_imp_orders_side.0 orders ---------------------------------------------------------------------------- sub: recfun.remove_imp_orders.remove_imp_orders_side.0 (List.tl orders) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [(List.hd orders).o_is_implied && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.018s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 5 ---------------------------------------------------------------------------- arith-make-feasible: 33 ---------------------------------------------------------------------------- arith-max-columns: 40 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 42957 ---------------------------------------------------------------------------- mk clause: 79 ---------------------------------------------------------------------------- datatype occurs check: 62 ---------------------------------------------------------------------------- mk bool var: 236 ---------------------------------------------------------------------------- arith-lower: 17 ---------------------------------------------------------------------------- datatype splits: 35 ---------------------------------------------------------------------------- decisions: 44 ---------------------------------------------------------------------------- propagations: 47 ---------------------------------------------------------------------------- interface eqs: 5 ---------------------------------------------------------------------------- arith-max-rows: 17 ---------------------------------------------------------------------------- conflicts: 7 ---------------------------------------------------------------------------- datatype accessor ax: 30 ---------------------------------------------------------------------------- datatype constructor ax: 59 ---------------------------------------------------------------------------- num allocs: 231473287 ---------------------------------------------------------------------------- final checks: 11 ---------------------------------------------------------------------------- added eqs: 264 ---------------------------------------------------------------------------- del clause: 45 ---------------------------------------------------------------------------- arith eq adapter: 16 ---------------------------------------------------------------------------- arith-upper: 27 ---------------------------------------------------------------------------- memory: 32.640000 ---------------------------------------------------------------------------- max memory: 32.640000 } } }) (full: * ```start[0.018s] let (_x_0 : int) = count.list count.order orders in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = count.list count.order _x_1 in let (_x_3 : bool) = (List.hd _x_1).o_is_implied in let (_x_4 : bool) = not Is_a([], _x_1) in (List.hd orders).o_is_implied && not Is_a([], orders) && _x_0 >= 0 && _x_2 >= 0 ==> not (_x_3 && _x_4) && not (not _x_3 && _x_4) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : int) = count.list count.order orders in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = count.list count.order _x_1 in let (_x_3 : bool) = (List.hd _x_1).o_is_implied in let (_x_4 : bool) = not Is_a([], _x_1) in (not ((((List.hd orders).o_is_implied && not Is_a([], orders)) && _x_0 >= 0) && _x_2 >= 0) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)) || not (_x_3 && _x_4) && not (not _x_3 && _x_4)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * Unsat)) }
call `recfun.remove_imp_orders.remove_imp_orders_side.0 (List.tl orders)` from `recfun.remove_imp_orders.remove_imp_orders_side.0 orders`
{original: recfun.remove_imp_orders.remove_imp_orders_side.0 orders ---------------------------------------------------------------------------- sub: recfun.remove_imp_orders.remove_imp_orders_side.0 (List.tl orders) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt orders) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl orders)) ---------------------------------------------------------------------------- path: [not (List.hd orders).o_is_implied && not Is_a([], orders)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.017s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 8 ---------------------------------------------------------------------------- arith-assume-eqs: 15 ---------------------------------------------------------------------------- arith-make-feasible: 78 ---------------------------------------------------------------------------- arith-max-columns: 61 ---------------------------------------------------------------------------- arith-conflicts: 2 ---------------------------------------------------------------------------- rlimit count: 38987 ---------------------------------------------------------------------------- mk clause: 134 ---------------------------------------------------------------------------- datatype occurs check: 106 ---------------------------------------------------------------------------- mk bool var: 300 ---------------------------------------------------------------------------- arith-lower: 42 ---------------------------------------------------------------------------- datatype splits: 39 ---------------------------------------------------------------------------- decisions: 78 ---------------------------------------------------------------------------- propagations: 86 ---------------------------------------------------------------------------- interface eqs: 15 ---------------------------------------------------------------------------- arith-max-rows: 30 ---------------------------------------------------------------------------- conflicts: 7 ---------------------------------------------------------------------------- datatype accessor ax: 31 ---------------------------------------------------------------------------- datatype constructor ax: 59 ---------------------------------------------------------------------------- num allocs: 215926135 ---------------------------------------------------------------------------- final checks: 21 ---------------------------------------------------------------------------- added eqs: 321 ---------------------------------------------------------------------------- del clause: 100 ---------------------------------------------------------------------------- arith eq adapter: 41 ---------------------------------------------------------------------------- arith-upper: 67 ---------------------------------------------------------------------------- memory: 29.950000 ---------------------------------------------------------------------------- max memory: 29.950000 } } }) (full: * ```start[0.017s] let (_x_0 : int) = count.list count.order orders in let (_x_1 : order list) = List.tl orders in let (_x_2 : int) = count.list count.order _x_1 in let (_x_3 : bool) = (List.hd _x_1).o_is_implied in let (_x_4 : bool) = not Is_a([], _x_1) in not (List.hd orders).o_is_implied && not Is_a([], orders) && _x_0 >= 0 && _x_2 >= 0 ==> not (_x_3 && _x_4) && not (not _x_3 && _x_4) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : order list) = List.tl orders in let (_x_1 : int) = count.list count.order _x_0 in let (_x_2 : int) = count.list count.order orders in let (_x_3 : bool) = (List.hd _x_0).o_is_implied in let (_x_4 : bool) = not Is_a([], _x_0) in (Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2) || not (((not (List.hd orders).o_is_implied && not Is_a([], orders)) && _x_2 >= 0) && _x_1 >= 0)) || not (_x_3 && _x_4) && not (not _x_3 && _x_4)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.order; spec_ty = (order -> int)/1111 }`…` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }

3.4 Implied uncrossing (for single side)

Try this!
In [23]:
(* The actual cycle *)
let implied_uncross_side (sd : side) (s_id : strategy_id) (s : strategy) (m : market) =

  (* 0. get the top of the book s*)
  let book1 = get_book_tops m.out_book1 in
  let book2 = get_book_tops m.out_book2 in
  let book3 = get_book_tops m.out_book3 in

  let books_tops = { book1; book2; book3 } in

  (* 1. calculate the implied orders that are available right now... *)
  let imp_order = calc_implied_strat_order s_id s books_tops sd m.curr_time in

  (* Need to increase the order ID first *)
  let new_ord_id = m.last_ord_id + 1 in

  (* 2. insert them into the order book *)
  let strat_book =
    begin
      match s_id with
      | STRAT1 -> insert_order { imp_order with o_id = new_ord_id } m.s_book1
      | STRAT2 -> insert_order { imp_order with o_id = new_ord_id } m.s_book2
    end in

  (* 3. perform the uncross - get the fills, etc... *)
  let unc_result = uncross_book strat_book [] 0 in

  let fq = unc_result.uncrossed_qty in

  if fq = 0 then
    (* Since we didn't trade anything, let's just return the original market state *)
    m
  else

  let adjust (mult : int) =
    let mult = -mult in
    if sd = BUY then mult else -mult in

  let adj_mul1 = adjust s.leg1.leg_mult in
  let adj_mul2 = adjust s.leg2.leg_mult in
  let adj_mul3 = adjust s.leg3.leg_mult in

  (* calculate the prices at which outright orders will trade *)
  let price1 = calc_implied_trade_price adj_mul1 book1 in
  let price2 = calc_implied_trade_price adj_mul2 book2 in
  let price3 = calc_implied_trade_price adj_mul3 book3 in

  (* 4. allocate fills to the outright orders *)
  let out_book1_res = allocate_implied_fills m.out_book1 (fq * adj_mul1) price1 m.curr_time in
  let out_book2_res = allocate_implied_fills m.out_book2 (fq * adj_mul2) price2 m.curr_time in
  let out_book3_res = allocate_implied_fills m.out_book3 (fq * adj_mul3) price3 m.curr_time in

  (* 5. remove the implied orders - notice that the uncrossed result contains a new book
    with partial fills *)
  let m = match s_id with
  | STRAT1 -> { m with s_book1 = remove_imp_orders unc_result.uncrossed_book }
  | STRAT2 -> { m with s_book2 = remove_imp_orders unc_result.uncrossed_book } in

  (* 6. let's now gather all of the fills and turn them into outbound messages *)
  let new_fill_msgs = create_fill_msgs (unc_result.uncrossed_fills @ out_book1_res.uncrossed_fills
    @ out_book2_res.uncrossed_fills @ out_book3_res.uncrossed_fills) in

  { m with
    outbound_msgs = new_fill_msgs @ m.outbound_msgs
    ; out_book1 = out_book1_res.uncrossed_book
    ; out_book2 = out_book2_res.uncrossed_book
    ; out_book3 = out_book3_res.uncrossed_book
    ; last_ord_id = new_ord_id }
;;
Out[23]:
val implied_uncross_side :
  side -> strategy_id -> strategy -> market -> market = <fun>

Let's now experiment with some concrete examples.

Try this!
In [24]:
#program;;
(* #remove_doc doc_of_market;; *)
#logic;;

let strat = {
  time_created = 1;
  leg1    = { leg_sec_idx = OUT1; leg_mult = 1 }
  ; leg2  = { leg_sec_idx = OUT2; leg_mult = -2 }
  ; leg3  = { leg_sec_idx = OUT3; leg_mult = 0 }
};;

let books = {
    book1 = { bid_info = Some { li_qty = 500; li_price = 50 } ; ask_info = Some { li_qty = 750 ; li_price = 50 }}
  ; book2 = { bid_info = Some { li_qty = 200 ; li_price = 60 }; ask_info = Some { li_qty = 500 ; li_price = 70 }}
  ; book3 = { bid_info = None ; ask_info = None }
};;

let m = {
  curr_time = 1

  ; last_ord_id = 0

  (* first strategy is 2*x1 - x2 + x3 *)
  ; strat1 = (make_strat 1 2 (-1) 1)
  (* second strategy is just the 3rd outright security *)
  ; strat2 = (make_strat 2 0 1 0)

  (* outright books *)
  ; out_book1 = {
    b_buys = [ (make BUY 500 50 1 (Outright OUT1) 1 false 1) ]
    ; b_sells = [ (make SELL 750 55 2 (Outright OUT1) 1 false 1) ]
  }

  ; out_book2 = {
    b_buys = [ (make BUY 200 60 3 (Outright OUT1) 1 false 1) ]
    ; b_sells = [ (make SELL 500 70 4 (Outright OUT1) 1 false 1) ]
  }

  ; out_book3 = {
    b_buys = [ ]
    ; b_sells = []
  }

  (* Strategy books *)
  ; s_book1 = {
    b_buys = [
    ]
    ; b_sells = [
      (make SELL 100 (-100) 5 (Strategy STRAT1) 1 false 1)
    ]
  }
  ; s_book2 = empty_book

  (* Inbound and outbound message queues *)
  ; inbound_msgs = []
  ; outbound_msgs = []
} in

let m' = implied_uncross_side BUY STRAT1 strat m in

(*calc_implied_strat_order STRAT1 m.strat1 books BUY 1 *)
m'.outbound_msgs
Out[24]:
val strat : strategy =
  {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 1};
   leg2 = {leg_sec_idx = OUT2; leg_mult = -2};
   leg3 = {leg_sec_idx = OUT3; leg_mult = 0}}
val books : books_info =
  {book1 =
    {bid_info = Some {li_qty = 500; li_price = 50};
     ask_info = Some {li_qty = 750; li_price = 50}};
   book2 =
    {bid_info = Some {li_qty = 200; li_price = 60};
     ask_info = Some {li_qty = 500; li_price = 70}};
   book3 = {bid_info = None; ask_info = None}}
- : outbound_msg list =
[Fill
  {fill_client_id = 1; fill_qty = 100; fill_price = -95; fill_order_id = 5;
   fill_order_done = true};
 Fill
  {fill_client_id = 1; fill_qty = 100; fill_price = 50; fill_order_id = 1;
   fill_order_done = true};
 Fill
  {fill_client_id = 1; fill_qty = 200; fill_price = 70; fill_order_id = 4;
   fill_order_done = true}]

3.5 Implied uncrossing decomposition

Try this!
In [25]:
(* Let's try to decompose the logic of 'implied_uncross_side' - we will put
   several functions in the basis to focus on the critical aspects of the logic *)
#timeout 1000;;

let d = Modular_decomp.top "implied_uncross_side"
        ~basis:["get_book_tops"; "allocate_implied_fills"; "insert_order";
        "create_fill_msgs"; "calc_implied_strat_order"] ~prune:true [@@program];;
Out[25]:
val d : Top_result.modular_decomposition =
  {Imandra_interactive.Modular_decomp.MD.md_session = 1i;
   md_f =
    {Imandra_surface.Uid.name = "implied_uncross_side"; id = <abstr>;
     special_tag = <abstr>; namespace = <abstr>;
     chash = Some AzqJrVf//IR4svQ6h8ebqChj2qn7CR9Y+l+LugkE2Wk;
     depth = (6i, 8i)};
   md_args = [(sd : side);(s_id : strategy_id);(s : strategy);(m : market)];
   md_regions = <abstr>}
Regions details

No group selected.

  • Concrete regions are numbered
  • Unnumbered regions are groups whose children share a particular constraint
  • Click on a region to view its details
  • Double click on a region to zoom in on it
  • Shift+double click to zoom out
  • Hit escape to reset back to the top
decomp of (implied_uncross_side sd, s_id, s, m
Reg_idConstraintsInvariant
257
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
256
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
255
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
254
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
253
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
252
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
251
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
250
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
249
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
248
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
247
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
246
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
245
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
244
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
243
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
242
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
241
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
240
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
239
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
238
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
237
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
236
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
235
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
234
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
233
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
232
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
231
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
230
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
229
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
228
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
227
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
226
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
225
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
224
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
223
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
222
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
221
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
220
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
219
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
218
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
217
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
216
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
215
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
214
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
213
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
212
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
211
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
210
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
209
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
208
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
207
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
206
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
205
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
204
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
203
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
202
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
201
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
200
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
199
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
198
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
197
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
196
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
195
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
194
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
193
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
192
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
191
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
190
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
189
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
188
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
187
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
186
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
185
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
184
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
183
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
182
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
181
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
180
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
179
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
178
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
177
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
176
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
175
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
174
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
173
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
172
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
171
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
170
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
169
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
168
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
167
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
166
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
165
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
164
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
163
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
162
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
161
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
160
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
159
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
158
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
157
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
156
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
155
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
154
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
153
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
152
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
151
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
150
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
149
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
148
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
147
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
146
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
145
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
144
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
143
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
142
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
141
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
140
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
139
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
138
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
137
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
136
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
135
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
134
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
133
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
132
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
131
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
130
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book2)
  [] 0).uncrossed_qty
 = 0)
  • not (s_id = STRAT1)
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book2)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book2 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
129
  • (uncross_book
 (insert_order
  {calc_implied_strat_order s_id s
   {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
    book3 = get_book_tops m.out_book3}
   sd m.curr_time
  with o_id = m.last_ord_id + 1} m.s_book2)
 [] 0).uncrossed_qty
= 0
  • not (s_id = STRAT1)
m
128
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
127
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
126
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
125
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
124
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
123
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
122
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
121
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
120
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
119
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
118
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
117
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
116
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
115
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
114
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
113
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
112
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
111
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
110
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
109
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
108
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
107
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
106
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
105
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
104
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
103
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
102
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
101
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
100
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
99
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
98
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
97
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- (~- s.leg1.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
96
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
95
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
94
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
93
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
92
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
91
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
90
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
89
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
88
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
87
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
86
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
85
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- (~- s.leg3.leg_mult)) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
84
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
83
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
82
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- (~- s.leg2.leg_mult)) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
81
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult))
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
80
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
79
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
78
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
77
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
76
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
75
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
74
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
73
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- (~- s.leg2.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
72
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
71
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
70
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- (~- s.leg1.leg_mult)) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
69
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult))
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- (~- s.leg3.leg_mult)) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
68
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
67
  • not ((~- (~- s.leg3.leg_mult)) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
66
  • (~- (~- s.leg3.leg_mult)) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- (~- s.leg1.leg_mult)) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- (~- s.leg2.leg_mult)) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- (~- s.leg3.leg_mult))
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
65
  • (~- (~- s.leg3.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- (~- s.leg2.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- (~- s.leg1.leg_mult)) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • not (sd = BUY)
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- (~- s.leg1.leg_mult)) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- (~- s.leg2.leg_mult)) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- (~- s.leg3.leg_mult)) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
64
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
63
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
62
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
61
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
60
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
59
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
58
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
57
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
56
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
55
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
54
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
53
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
52
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
51
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
50
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
49
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.bid_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
48
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
47
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
46
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
45
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
44
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
43
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
42
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
41
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
40
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
39
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
38
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
37
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
36
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
35
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
34
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
33
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • not ((~- s.leg1.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book1).bid_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
32
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
31
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
30
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
29
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
28
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
27
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
26
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
25
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
24
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.bid_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
23
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
22
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : best_bid_ask) = get_book_tops _x_5 in
let (_x_7 : int) = m.curr_time in
let (_x_8 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = _x_6} sd _x_7
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_9 : int) = _x_8.uncrossed_qty in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_1 (_x_9 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_7
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_3 (_x_9 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_7
in
let (_x_12 : uncross_res)
    = allocate_implied_fills _x_5 (_x_9 * ~- s.leg3.leg_mult)
      (Option.get _x_6.ask_info).li_price _x_7
in
let (_x_13 : book) = _x_8.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_10.uncrossed_book;
out_book2 = _x_11.uncrossed_book; out_book3 = _x_12.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_13.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_8.uncrossed_fills
  (List.append _x_10.uncrossed_fills
   (List.append _x_11.uncrossed_fills _x_12.uncrossed_fills))))
m.outbound_msgs}
21
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : book) = m.out_book3 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = _x_4; book3 = get_book_tops _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_5 (_x_8 * ~- s.leg3.leg_mult) 0 _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
20
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
19
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
18
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_8 * ~- s.leg2.leg_mult) 0 _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
17
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : best_bid_ask) = get_book_tops _x_1 in
let (_x_3 : book) = m.out_book2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = _x_2; book2 = get_book_tops _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult)
      (Option.get _x_2.ask_info).li_price _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
16
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
15
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
14
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
13
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.bid_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
12
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
11
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
10
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
9
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • not ((~- s.leg2.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book2).bid_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
8
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.bid_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
7
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
6
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : best_bid_ask) = get_book_tops _x_4 in
let (_x_6 : int) = m.curr_time in
let (_x_7 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = _x_5} sd _x_6
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_8 : int) = _x_7.uncrossed_qty in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_1 (_x_8 * ~- s.leg1.leg_mult) 0 _x_6
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_2 (_x_8 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_6
in
let (_x_11 : uncross_res)
    = allocate_implied_fills _x_4 (_x_8 * ~- s.leg3.leg_mult)
      (Option.get _x_5.ask_info).li_price _x_6
in
let (_x_12 : book) = _x_7.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_9.uncrossed_book;
out_book2 = _x_10.uncrossed_book; out_book3 = _x_11.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_12.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_7.uncrossed_fills
  (List.append _x_9.uncrossed_fills
   (List.append _x_10.uncrossed_fills _x_11.uncrossed_fills))))
m.outbound_msgs}
5
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : best_bid_ask) = get_book_tops _x_2 in
let (_x_4 : book) = m.out_book3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = _x_3; book3 = get_book_tops _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult)
      (Option.get _x_3.ask_info).li_price _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_4 (_x_7 * ~- s.leg3.leg_mult) 0 _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
4
  • not ((~- s.leg3.leg_mult) > 0)
  • not Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.bid_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
3
  • not ((~- s.leg3.leg_mult) > 0)
  • Is_a(None, (get_book_tops m.out_book3).bid_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
2
  • (~- s.leg3.leg_mult) > 0
  • not Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : best_bid_ask) = get_book_tops _x_3 in
let (_x_5 : int) = m.curr_time in
let (_x_6 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2; book3 = _x_4}
        sd _x_5
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_7 : int) = _x_6.uncrossed_qty in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_1 (_x_7 * ~- s.leg1.leg_mult) 0 _x_5
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_2 (_x_7 * ~- s.leg2.leg_mult) 0 _x_5
in
let (_x_10 : uncross_res)
    = allocate_implied_fills _x_3 (_x_7 * ~- s.leg3.leg_mult)
      (Option.get _x_4.ask_info).li_price _x_5
in
let (_x_11 : book) = _x_6.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_8.uncrossed_book;
out_book2 = _x_9.uncrossed_book; out_book3 = _x_10.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_11.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_6.uncrossed_fills
  (List.append _x_8.uncrossed_fills
   (List.append _x_9.uncrossed_fills _x_10.uncrossed_fills))))
m.outbound_msgs}
1
  • (~- s.leg3.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book3).ask_info)
  • (~- s.leg2.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book2).ask_info)
  • (~- s.leg1.leg_mult) > 0
  • Is_a(None, (get_book_tops m.out_book1).ask_info)
  • sd = BUY
  • not
((uncross_book
  (insert_order
   {calc_implied_strat_order s_id s
    {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
     book3 = get_book_tops m.out_book3}
    sd m.curr_time
   with o_id = m.last_ord_id + 1} m.s_book1)
  [] 0).uncrossed_qty
 = 0)
  • s_id = STRAT1
let (_x_0 : int) = m.last_ord_id + 1 in
let (_x_1 : book) = m.out_book1 in
let (_x_2 : book) = m.out_book2 in
let (_x_3 : book) = m.out_book3 in
let (_x_4 : int) = m.curr_time in
let (_x_5 : uncross_res)
    = uncross_book
      (insert_order
       {calc_implied_strat_order s_id s
        {book1 = get_book_tops _x_1; book2 = get_book_tops _x_2;
         book3 = get_book_tops _x_3}
        sd _x_4
       with o_id = _x_0} m.s_book1)
      [] 0
in
let (_x_6 : int) = _x_5.uncrossed_qty in
let (_x_7 : uncross_res)
    = allocate_implied_fills _x_1 (_x_6 * ~- s.leg1.leg_mult) 0 _x_4
in
let (_x_8 : uncross_res)
    = allocate_implied_fills _x_2 (_x_6 * ~- s.leg2.leg_mult) 0 _x_4
in
let (_x_9 : uncross_res)
    = allocate_implied_fills _x_3 (_x_6 * ~- s.leg3.leg_mult) 0 _x_4
in
let (_x_10 : book) = _x_5.uncrossed_book in
{m with
last_ord_id = _x_0; out_book1 = _x_7.uncrossed_book;
out_book2 = _x_8.uncrossed_book; out_book3 = _x_9.uncrossed_book;
s_book1 =
{b_buys = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_buys;
 b_sells = recfun.remove_imp_orders.remove_imp_orders_side.0 _x_10.b_sells};
outbound_msgs =
List.append
(create_fill_msgs
 (List.append _x_5.uncrossed_fills
  (List.append _x_7.uncrossed_fills
   (List.append _x_8.uncrossed_fills _x_9.uncrossed_fills))))
m.outbound_msgs}
0
  • (uncross_book
 (insert_order
  {calc_implied_strat_order s_id s
   {book1 = get_book_tops m.out_book1; book2 = get_book_tops m.out_book2;
    book3 = get_book_tops m.out_book3}
   sd m.curr_time
  with o_id = m.last_ord_id + 1} m.s_book1)
 [] 0).uncrossed_qty
= 0
  • s_id = STRAT1
m

3.6 Full book implied uncross

Try this!
In [26]:
(* The implied uncross algorithm *)
let implied_uncross_books (s : strategy_id) (m : market) =
  if s = STRAT1 then
    begin
      let m = implied_uncross_side BUY s m.strat1 m in
      implied_uncross_side SELL s m.strat1 m
    end
  else
    begin
      let m = implied_uncross_side BUY s m.strat2 m in
      implied_uncross_side SELL s m.strat2 m
    end
Out[26]:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      val implied_uncross_books : strategy_id -> market -> market = <fun>

4. Global state transition functions functions

4.1 Insert order

Try this!
In [27]:
(* Perform operation to create and insert a new order *)
let run_new_order (m : market) (no : new_ord_msg) =
  let new_o_id = m.last_ord_id + 1 in
  let o = {
    o_id = new_o_id
    ; o_qty = no.no_qty
    ; o_price = no.no_price
    ; o_time = m.curr_time
    ; o_side = no.no_side
    ; o_client_id = no.no_client_id
    ; o_inst = no.no_inst_type
    ; o_is_implied = false (* these are always outright *)
  } in

  let m' =
    match no.no_inst_type with
    | Strategy STRAT1 -> { m with s_book1 = (insert_order o m.s_book1) }
    | Strategy STRAT2 -> { m with s_book2 = (insert_order o m.s_book2) }
    | Outright OUT1   -> { m with out_book1 = (insert_order o m.out_book1) }
    | Outright OUT2   -> { m with out_book2 = (insert_order o m.out_book2) }
    | Outright OUT3   -> { m with out_book3 = (insert_order o m.out_book3) }

  in { m' with last_ord_id = new_o_id }
Out[27]:
val run_new_order : market -> new_ord_msg -> market = <fun>

4.2 Cancel order

Try this!
In [28]:
(* Cancel an order *)
let run_cancel_order (m : market) (co : cancel_ord_msg) =
  match co.co_instrument with
  | Strategy STRAT1 -> {m with s_book1 = (cancel_ord_book co m.s_book1)}
  | Strategy STRAT2 -> {m with s_book2 = (cancel_ord_book co m.s_book2)}
  | Outright OUT1 -> {m with out_book1 = (cancel_ord_book co m.out_book1)}
  | Outright OUT2 -> {m with out_book2 = (cancel_ord_book co m.out_book2)}
  | Outright OUT3 -> {m with out_book3 = (cancel_ord_book co m.out_book3)}
Out[28]:
val run_cancel_order : market -> cancel_ord_msg -> market = <fun>

4.3 Run implied uncross

Try this!
In [29]:
(* Perform opreation to execute new fill *)
let run_implied_uncross (m : market) =

  (* Do the typical uncross between the strategies *)
  let sbook1_res = uncross_book m.s_book1 [] 0 in
  let sbook2_res = uncross_book m.s_book2 [] 0 in

  (*  outright books  *)
  let obook1_res = uncross_book m.out_book1 [] 0 in
  let obook2_res = uncross_book m.out_book2 [] 0 in
  let obook3_res = uncross_book m.out_book3 [] 0 in

  (* Now let's update the entire market state *)
  let m' = {
    m with
      s_book1 = sbook1_res.uncrossed_book
      ; s_book2 = sbook2_res.uncrossed_book

      ; out_book1 = obook1_res.uncrossed_book
      ; out_book2 = obook2_res.uncrossed_book
      ; out_book3 = obook3_res.uncrossed_book

      ; outbound_msgs =
          create_fill_msgs (
            sbook1_res.uncrossed_fills @
            sbook2_res.uncrossed_fills @
            obook1_res.uncrossed_fills @
            obook2_res.uncrossed_fills @
            obook3_res.uncrossed_fills )
  } in

  (* Now we should be done with uncrossing the books the old way,
    let's now create implied orders here.
    Notice that we're using the priority function to determine which
    strategy order book runs first... *)
  if priority_strat m'.strat1 m'.strat2 then
    let m' = implied_uncross_books STRAT1 m' in
    (implied_uncross_books STRAT2 m')
  else
    let m' = implied_uncross_books STRAT2 m' in
    (implied_uncross_books STRAT1 m')

;;
Out[29]:
val run_implied_uncross : market -> market = <fun>
Try this!
In [30]:
(* Now is a time for a full market uncross. *)

let m2 = {
  curr_time = 1

  ; last_ord_id = 0

  (* In a larger model, we can *)
  (* first strategy is 2*x1 - x2 + x3 *)
  ; strat1 = (make_strat 1 2 (-1) 1)
  (* second strategy is just the 3rd outright security *)
  ; strat2 = (make_strat 2 0 1 0)

  (* outright books *)
  ; out_book1 = {
    b_buys = [ (make BUY 500 50 1 (Outright OUT1) 1 false 1) ]
    ; b_sells = [ (make SELL 750 55 2 (Outright OUT1) 1 false 1) ]
  }

  ; out_book2 = {
    b_buys = [ (make BUY 200 60 3 (Outright OUT1) 1 false 1) ]
    ; b_sells = [ (make SELL 500 70 4 (Outright OUT1) 1 false 1) ]
  }
  ; out_book3 = empty_book

  (* Strategy books *)
  ; s_book1 = empty_book
  ; s_book2 = empty_book

  (* Inbound and outbound message queues *)
  ; inbound_msgs = []
  ; outbound_msgs = []
}
Out[30]:
val m2 : market =
  {curr_time = 1; last_ord_id = 0;
   strat1 =
    {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 2};
     leg2 = {leg_sec_idx = OUT2; leg_mult = -1};
     leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
   strat2 =
    {time_created = 2; leg1 = {leg_sec_idx = OUT1; leg_mult = 0};
     leg2 = {leg_sec_idx = OUT2; leg_mult = 1};
     leg3 = {leg_sec_idx = OUT3; leg_mult = 0}};
   out_book1 =
    {b_buys =
      [{o_qty = 500; o_price = 50; o_time = 1; o_id = 1; o_side = BUY;
        o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
     b_sells =
      [{o_qty = 750; o_price = 55; o_time = 1; o_id = 2; o_side = SELL;
        o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
   out_book2 =
    {b_buys =
      [{o_qty = 200; o_price = 60; o_time = 1; o_id = 3; o_side = BUY;
        o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}];
     b_sells =
      [{o_qty = 500; o_price = 70; o_time = 1; o_id = 4; o_side = SELL;
        o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
   out_book3 = {b_buys = []; b_sells = []};
   s_book1 = {b_buys = []; b_sells = []};
   s_book2 = {b_buys = []; b_sells = []}; inbound_msgs = [];
   outbound_msgs = []}

4.4 Main transition function

This is where we put it all together. Note that this is a 'shortened' version of the full model - in a complete model we would allow new strategies to be created, more intricate state transitions (e.g. auctions) and much more.

Try this!
In [31]:
(* The main state transition loop of the exchange state *)
let step (m : market) (msg : inbound_msg) =
 begin
  match msg with
  | NewOrder no -> run_new_order m no
  | CancelOrder co -> run_cancel_order m co
  | ImpliedUncross -> run_implied_uncross m
 end
;;

let rec run (m: market) (msgs : inbound_msg list) =
 match msgs with
 | [] -> []
 | x::xs -> let m' = step m x in
   m' :: (run m' xs)
;;
Out[31]:
val step : market -> inbound_msg -> market = <fun>
val run : market -> inbound_msg list -> market list = <fun>
termination proof

Termination proof

call `run (step m (List.hd msgs)) (List.tl msgs)` from `run m msgs`
{original: run m msgs ---------------------------------------------------------------------------- sub: run (step m (List.hd msgs)) (List.tl msgs) ---------------------------------------------------------------------------- original ordinal: Ordinal.Int (_cnt msgs) ---------------------------------------------------------------------------- sub ordinal: Ordinal.Int (_cnt (List.tl msgs)) ---------------------------------------------------------------------------- path: [not Is_a([], msgs)] ---------------------------------------------------------------------------- proof: (alternatives (summary: {ground_instances: 3 ---------------------------------------------------------------------------- definitions: 0 ---------------------------------------------------------------------------- inductions: 0 ---------------------------------------------------------------------------- search_time: `0.025s` ---------------------------------------------------------------------------- details: {smt_stats: {num checks: 7 ---------------------------------------------------------------------------- arith-assume-eqs: 1 ---------------------------------------------------------------------------- arith-make-feasible: 149 ---------------------------------------------------------------------------- arith-max-columns: 62 ---------------------------------------------------------------------------- arith-conflicts: 13 ---------------------------------------------------------------------------- rlimit count: 68754715 ---------------------------------------------------------------------------- arith-cheap-eqs: 12 ---------------------------------------------------------------------------- mk clause: 171 ---------------------------------------------------------------------------- datatype occurs check: 20 ---------------------------------------------------------------------------- mk bool var: 657 ---------------------------------------------------------------------------- arith-lower: 119 ---------------------------------------------------------------------------- arith-diseq: 18 ---------------------------------------------------------------------------- datatype splits: 127 ---------------------------------------------------------------------------- decisions: 273 ---------------------------------------------------------------------------- arith-propagations: 10 ---------------------------------------------------------------------------- propagations: 241 ---------------------------------------------------------------------------- interface eqs: 1 ---------------------------------------------------------------------------- arith-bound-propagations-cheap: 10 ---------------------------------------------------------------------------- arith-max-rows: 25 ---------------------------------------------------------------------------- conflicts: 32 ---------------------------------------------------------------------------- datatype accessor ax: 96 ---------------------------------------------------------------------------- minimized lits: 3 ---------------------------------------------------------------------------- arith-bound-propagations-lp: 6 ---------------------------------------------------------------------------- datatype constructor ax: 159 ---------------------------------------------------------------------------- final checks: 5 ---------------------------------------------------------------------------- added eqs: 826 ---------------------------------------------------------------------------- del clause: 101 ---------------------------------------------------------------------------- arith eq adapter: 92 ---------------------------------------------------------------------------- arith-upper: 118 ---------------------------------------------------------------------------- memory: 570.300000 ---------------------------------------------------------------------------- max memory: 580.330000 ---------------------------------------------------------------------------- num allocs: 402654882703.000000 } } }) (full: * ```start[0.025s] let (_x_0 : int) = count.list count.inbound_msg msgs in let (_x_1 : inbound_msg list) = List.tl msgs in let (_x_2 : int) = count.list count.inbound_msg _x_1 in not Is_a([], msgs) && _x_0 >= 0 && _x_2 >= 0 ==> Is_a([], _x_1) || Ordinal.( << ) (Ordinal.Int _x_2) (Ordinal.Int _x_0)``` * simplify:: {into: ```let (_x_0 : inbound_msg list) = List.tl msgs in let (_x_1 : int) = count.list count.inbound_msg _x_0 in let (_x_2 : int) = count.list count.inbound_msg msgs in (Is_a([], _x_0) || Ordinal.( << ) (Ordinal.Int _x_1) (Ordinal.Int _x_2)) || not ((not Is_a([], msgs) && _x_2 >= 0) && _x_1 >= 0)``` ---------------------------------------------------------------------------- expansions: `[]` ---------------------------------------------------------------------------- rewrite_steps: ---------------------------------------------------------------------------- forward_chaining: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.inbound_msg; spec_ty = (inbound_msg -> …` ---------------------------------------------------------------------------- expansions: } * unroll {expr: `(|`count.list { Resolved_term.spec_idx = 0; spec_arg = count.inbound_msg; spec_ty = (inbound_msg -> …` ---------------------------------------------------------------------------- expansions: } * unroll {expr: ```(|Ordinal.<<_126| (|Ordinal.Int_111| (|`count.list { Resolved_term.spec_idx = 0;…``` ---------------------------------------------------------------------------- expansions: } * Unsat)) }

5. Complete examples

Now let's have a complete example that shows how to insert and then trade outright and strategy orders

Try this!
In [32]:
let m4 = {

  curr_time = 1

  ; last_ord_id = 0

  (* first strategy is 2*x1 - x2 + x3 *)
  ; strat1 = (make_strat 1 2 (-1) 1)
  (* second strategy is just the 3rd outright security *)
  ; strat2 = (make_strat 2 0 0 1)

  (* outright books *)
  ; out_book1 = empty_book
  ; out_book2 = empty_book
  ; out_book3 = empty_book

  (* Strategy books *)
  ; s_book1 = empty_book
  ; s_book2 = empty_book

  (* Inbound and outbound message queues *)
  ; inbound_msgs = []
  ; outbound_msgs = []
} in

(* Helper function signature is: 'cid inst qty sd p'*)
let new_ord1_msg = make_no_msg 1 (Outright OUT1) 100 SELL 75 in
let new_ord2_msg = make_no_msg 2 (Outright OUT1) 75 BUY 80 in
let new_ord3_msg = make_no_msg 3 (Outright OUT1) 125 SELL 50 in

run m4 [new_ord1_msg; new_ord2_msg; new_ord3_msg];;
Out[32]:
- : market list =
[{curr_time = 1; last_ord_id = 1;
  strat1 =
   {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 2};
    leg2 = {leg_sec_idx = OUT2; leg_mult = -1};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  strat2 =
   {time_created = 2; leg1 = {leg_sec_idx = OUT1; leg_mult = 0};
    leg2 = {leg_sec_idx = OUT2; leg_mult = 0};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  out_book1 =
   {b_buys = [];
    b_sells =
     [{o_qty = 100; o_price = 75; o_time = 1; o_id = 1; o_side = SELL;
       o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
  out_book2 = {b_buys = []; b_sells = []};
  out_book3 = {b_buys = []; b_sells = []};
  s_book1 = {b_buys = []; b_sells = []};
  s_book2 = {b_buys = []; b_sells = []}; inbound_msgs = [];
  outbound_msgs = []};
 {curr_time = 1; last_ord_id = 2;
  strat1 =
   {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 2};
    leg2 = {leg_sec_idx = OUT2; leg_mult = -1};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  strat2 =
   {time_created = 2; leg1 = {leg_sec_idx = OUT1; leg_mult = 0};
    leg2 = {leg_sec_idx = OUT2; leg_mult = 0};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  out_book1 =
   {b_buys =
     [{o_qty = 75; o_price = 80; o_time = 1; o_id = 2; o_side = BUY;
       o_client_id = 2; o_inst = Outright OUT1; o_is_implied = false}];
    b_sells =
     [{o_qty = 100; o_price = 75; o_time = 1; o_id = 1; o_side = SELL;
       o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
  out_book2 = {b_buys = []; b_sells = []};
  out_book3 = {b_buys = []; b_sells = []};
  s_book1 = {b_buys = []; b_sells = []};
  s_book2 = {b_buys = []; b_sells = []}; inbound_msgs = [];
  outbound_msgs = []};
 {curr_time = 1; last_ord_id = 3;
  strat1 =
   {time_created = 1; leg1 = {leg_sec_idx = OUT1; leg_mult = 2};
    leg2 = {leg_sec_idx = OUT2; leg_mult = -1};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  strat2 =
   {time_created = 2; leg1 = {leg_sec_idx = OUT1; leg_mult = 0};
    leg2 = {leg_sec_idx = OUT2; leg_mult = 0};
    leg3 = {leg_sec_idx = OUT3; leg_mult = 1}};
  out_book1 =
   {b_buys =
     [{o_qty = 75; o_price = 80; o_time = 1; o_id = 2; o_side = BUY;
       o_client_id = 2; o_inst = Outright OUT1; o_is_implied = false}];
    b_sells =
     [{o_qty = 125; o_price = 50; o_time = 1; o_id = 3; o_side = SELL;
       o_client_id = 3; o_inst = Outright OUT1; o_is_implied = false};
      {o_qty = 100; o_price = 75; o_time = 1; o_id = 1; o_side = SELL;
       o_client_id = 1; o_inst = Outright OUT1; o_is_implied = false}]};
  out_book2 = {b_buys = []; b_sells = []};
  out_book3 = {b_buys = []; b_sells = []};
  s_book1 = {b_buys = []; b_sells = []};
  s_book2 = {b_buys = []; b_sells = []}; inbound_msgs = [];
  outbound_msgs = []}]